Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(react): connection pane and tab list (#20121)
ecmadaobadaf2fedf9c
diff --git a/docs/superpowers/specs/2026-04-24-sql-editor-react-migration-stage-14-design.md b/docs/superpowers/specs/2026-04-24-sql-editor-react-migration-stage-14-design.mdnew file mode 100644index 0000000000..f0c1788a85--- /dev/null+++ b/docs/superpowers/specs/2026-04-24-sql-editor-react-migration-stage-14-design.md@@ -0,0 +1,242 @@+# SQL Editor React Migration — Stage 14 Design++**Date:** 2026-04-24+**Author:** [email protected]+**Status:** Draft++## 1. Goal & non-goals++**Goal:** Port the two remaining sidebar-adjacent Vue subtrees — `TabList/` and `ConnectionPanel/` — to React end-to-end. After this stage, the **top-of-editor tab bar** and the **Connect-to-Database drawer** are 100% React; the only Vue surfaces left around the editor are the root `SQLEditorHomePage.vue` (deferred), the editor panels themselves (`EditorMain`/`StandardPanel`/`TerminalPanel` — host-only), the `SchemaPane` tree, and the `ResultView` subtree.++**Non-goals:**+- Migrating `SQLEditorHomePage.vue`, `EditorPanel.vue`, `StandardPanel.vue`, `EditorMain.vue`, `TerminalPanel.vue` — still Vue; they host these React mounts.+- Migrating `SchemaPane/*` or `ResultView/*` — separate stages.+- Refactoring `useSQLEditorTabStore`, `useSQLEditorContext`, or the connection picker's `useConnectionTreeContext` — the migration reads/writes them via `useVueState` / direct method calls.+- Visual or behavioral changes — parity only.+- Porting deep Vue dependencies (`RichDatabaseName`, `FeatureBadge`, `DatabaseIcon`, etc.) beyond the minimum needed. When a child Vue component has no React equivalent and isn't worth lifting alone, inline a local React display helper or mount it via `ReactPageMount` where feasible.++## 2. Inventory++### 2.1 TabList subtree (7 files, ~963 LOC)++| File | LOC | Notes |+|---|---|---|+| `TabList.vue` | 287 | Horizontal tab bar; `VueDraggable` for drag-reorder; `NScrollbar` for horizontal scroll; "+" button to add a tab; keyboard shortcut wiring. |+| `TabItem/TabItem.vue` | 133 | One tab; composes Prefix + Label + Suffix + AdminLabel. |+| `TabItem/Label.vue` | 161 | Tab title + in-place rename; hover tooltip. |+| `TabItem/Prefix.vue` | 48 | Leading icons (draft pencil, shared users, admin wrench, `SheetConnectionIcon` — already React via ReactPageMount). |+| `TabItem/Suffix.vue` | 104 | Close button + dirty indicator. |+| `TabItem/AdminLabel.vue` | 62 | "ADMIN" badge overlay. |+| `ContextMenu.vue` | 118 | Right-click: Close, Close others, Close to the right, Close all, Rename. |+| `context.ts` | 47 | Vue inject context (scrollbar ref, focus-tab helper). |++### 2.2 ConnectionPanel subtree (~14 files, ~1557 LOC)++| File | LOC | Notes |+|---|---|---|+| `ConnectionPanel.vue` | 79 | Shell: Drawer wrapping ConnectionPane. |+| `ConnectionPane/ConnectionPane.vue` | 853 | The big one — instance/database NTree + batch-mode + database groups + "select data source" radio + search. |+| `ConnectionPane/DatabaseGroupTable.vue` | 75 | Read-only table listing groups. |+| `ConnectionPane/DatabaseGroupTag.vue` | 35 | Small closable tag for selected groups. |+| `ConnectionPane/TreeNode/DatabaseNode.vue` | 72 | Database leaf rendering — mounted by arborist. |+| `ConnectionPane/TreeNode/InstanceNode.vue` | 40 | Instance internal node. |+| `ConnectionPane/TreeNode/LabelNode.vue` | 27 | Environment label group node. |+| `ConnectionPane/TreeNode/Label.vue` | 51 | Shared label renderer (name + tags + icons). |+| `ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.vue` | 160 | Popover that shows on hover over a database node. |+| `ConnectionPane/DatabaseHoverPanel/hover-state.ts` | 19 | Hover-timer state. |+| `ConnectionPane/tree.ts` | 138 | Builds the NTree data model from pinia. |+| Index/re-exports | ~8 total | Plumbing. |++## 3. External deps & primitives++| Vue dep | React replacement | Status |+|---|---|---|+| `VueDraggable` (`vue-draggable-plus`) | `@dnd-kit/core` + `@dnd-kit/sortable` | Already installed |+| `NScrollbar` | Native `overflow-x-auto` + our custom scrollbar CSS | No primitive needed; inline styles |+| `NDrawer` / `DrawerContent` | shadcn `Sheet` (existing in `src/react/components/ui/sheet.tsx`) | ✓ |+| `NTree` | `Tree` primitive (`src/react/components/ui/tree.tsx`) | ✓ from Stage 11 |+| `NTooltip` | `Tooltip` primitive | ✓ |+| `NPopover` | `Popover` primitive | ✓ |+| `NDivider` | `Separator` primitive | ✓ |+| `NTag` with `closable` | `Badge` + close icon composed manually | ✓ |+| `useDialog` (naive-ui imperative) | shadcn `AlertDialog` via local state | ✓ |+| `useResizeObserver` (@vueuse) | `useEffect` + `ResizeObserver` | Inline |+| `scroll-into-view-if-needed` | Same library (framework-agnostic) | ✓ |+| `usePreventBackAndForward` | Same utility (framework-agnostic) | ✓ |+| `RichDatabaseName`, `FeatureBadge`, `DatabaseIcon` | Inline minimal React versions; mount via `ReactPageMount` only if already ported | Case-by-case |++## 4. Architecture & phases++Five phases. Each commit-able independently, each green on `pnpm fix / type-check / test / check`.++### Phase 1 — TabList leaves++**Files ported:** `TabItem/AdminLabel.vue`, `TabItem/Prefix.vue`, `TabItem/Suffix.vue`, `TabItem/Label.vue`.++**Approach:** Presentational components. Each becomes a React component under `src/react/components/sql-editor/TabItem/`. They compose existing React primitives (Tooltip, Button, Input). `SheetConnectionIcon` (already React from Stage 13) is reused directly.++**Deliverables:** 4 `.tsx` + 3 tests (AdminLabel has no state worth covering; combine with Label test).++### Phase 2 — TabList shell + context menu++**Files ported:** `TabItem.vue` (composer), `TabList.vue` (draggable list), `ContextMenu.vue`, `context.ts`.++**Approach:**+- `TabList.tsx` wraps `@dnd-kit/sortable`'s `SortableContext` + `useSortable` around each tab row. Drag reorders `tabStore.openTabList` (Pinia array) via `tabStore.setOrder(...)` (existing method).+- Horizontal scrolling is a native `overflow-x-auto` container; sticky "+" button on the right.+- Context menu uses the existing `DropdownMenu` primitive; right-click on a tab fires `onContextMenuShow` to pick the target tab.+- Replaces `useTabListContext` Vue inject with direct store calls + `useVueState`.++**Deliverables:** `TabList.tsx`, `TabItem.tsx`, `TabContextMenu.tsx`, plus tests for (a) tab render from store, (b) click selects tab, (c) close fires store.closeTab, (d) drag reorders tab array, (e) context menu "Close others" fires correct store calls.++**Caller swap:** `SQLEditorHomePage.vue` — `<TabList />` → `<ReactPageMount page="TabList" container-class="w-full" />`.++### Phase 3 — ConnectionPanel tree nodes + hover panel++**Files ported:** `TreeNode/Label.vue`, `TreeNode/LabelNode.vue`, `TreeNode/InstanceNode.vue`, `TreeNode/DatabaseNode.vue`, `DatabaseHoverPanel.vue`, `hover-state.ts`.++**Deferred to Phase 4:** `tree.ts` — reading the source revealed it's a Vue composable (uses `useDebounceFn`, `ref`, `computed`, `watch`), not pure TS. Its port is coupled to `ConnectionPane` consumption, so it rides with Phase 4.++**Approach:**+- Each *Node.vue* becomes a small presentational React component under `src/react/components/sql-editor/ConnectionPane/TreeNode/`. `Label.tsx` is the shared renderer that dispatches on `node.meta.type`.+- `hover-state.ts` becomes a React context + `useProvideHoverState()` hook mirroring Vue's `useDelayedValue` semantics (1000ms open, 350ms close).+- `DatabaseHoverPanel.tsx` portals a `position: fixed` panel into the overlay layer, clamping y into the viewport and listening for mouseenter/leave + click-outside. Matches Vue visuals (environment / instance / project / labels grid).+- Inlined display logic (engine icon, environment tint, instance / project names) instead of creating full React ports of `EnvironmentV1Name` / `InstanceV1Name` / `RichDatabaseName` / `ProjectV1Name`. The `tree-node-database` class is preserved so existing CSS hooks still apply.++**Deliverables:** Per-node `.tsx` files + `Label.tsx` + `DatabaseHoverPanel.tsx` + `hover-state.ts` + tests for LabelNode (2), InstanceNode (3), DatabaseNode (4), Label dispatch (4), DatabaseHoverPanel render + clamp (3).++### Phase 4 — ConnectionPane + batch mode (sliced)++Reading the source turned up more scope than the original framing assumed. `ConnectionPane.vue` is 853 lines and depends on a context menu (`actions.tsx`, 225L), a no-React-equivalent `FeatureModal`, naive-ui `NTree`/`NTabs`/`NRadio`/`NCheckbox`/`NDivider`/`MaskSpinner`, and `DatabaseGroupDataTable.vue` (an independent multi-selection DataTable used outside SQL Editor too). We slice Phase 4 into four shippable chunks:++#### Phase 4a — Cheap leaves++**Files ported:** `DatabaseGroupTag.vue` → `DatabaseGroupTag.tsx`; Vue `tree.ts` composable → React hook `tree.ts` (`useSQLEditorTreeByEnvironment`).++Both are consumer-less at Phase 4a ship — they're staged for Phase 4d's `ConnectionPane.tsx`. Tests: DatabaseGroupTag (4).++#### Phase 4b — Context menu + FeatureModal++**Files ported:** `actions.tsx` → React `useConnectionMenu()` hook + `setConnection()` plain function + `ConnectionContextMenu.tsx` (imperative handle, mirrors the TabContextMenu invisible-trigger pattern).++**New:** `src/react/components/ui/feature-modal.tsx` — shadcn Dialog wrapping the subscription paywall strings from `dynamic.subscription.features.*`. Used by ConnectionPane to gate batch-query + database-group features.++Both are standalone — Phase 4b doesn't swap any callers.++#### Phase 4c — DatabaseGroup data table++**Files ported:** `DatabaseGroupDataTable.vue` → `DatabaseGroupDataTable.tsx` (shared component, used by SQL Editor + elsewhere); then `DatabaseGroupTable.vue` → `DatabaseGroupTable.tsx` (thin wrapper: search box + data table + controlled selection).++Consumer-less — Phase 4d's `ConnectionPane.tsx` picks it up. The broader migration of non-SQL-Editor consumers of the Vue DataTable is tracked separately.++#### Phase 4d — ConnectionPane shell + caller swap++**Files ported:** `ConnectionPane.vue` → `ConnectionPane.tsx` (uses Phase 4a/b/c artifacts, Phase 3 leaves, Stage 11 Tree primitive, React AdvancedSearch).++**Caller swap:** `ConnectionPanel.vue` (still Vue) replaces `<ConnectionPane>` with `<ReactPageMount page="ConnectionPane" :show="isOpen" />`. Phase 5 then swaps the outer `ConnectionPanel` shell.++**Deliverables:** `ConnectionPane.tsx` + 5 tests + delete Vue `ConnectionPane/*.vue` + `actions.tsx` + `tree.ts` + `DatabaseHoverPanel/*.vue` + `TreeNode/*.vue` + `index.ts`.++### Phase 5 — Shell + caller swap + cleanup++**Files ported:** `ConnectionPanel.vue` (the Drawer shell) → `ConnectionPanel.tsx` (uses shadcn `Sheet`).++**Approach:**+- `ConnectionPanel.tsx` wraps `ConnectionPane` in `<Sheet open onOpenChange>`. Width tier from the sheet primitive; override with `width="wide"` (832px). Reads the Vue-side `showConnectionPanel` ref through props passed by `SQLEditorHomePage.vue`'s `ReactPageMount`.++**Caller swap:**+- `SQLEditorHomePage.vue`: `<ConnectionPanel v-model:show="showConnectionPanel" />` → `<ReactPageMount page="ConnectionPanel" :open="showConnectionPanel" :onOpenChange="(v) => (showConnectionPanel = v)" />`.++**Delete:** All ported Vue files + their `index.ts`.++**Verify:**+- `rg "TabList/|ConnectionPanel/|ConnectionPane"` → zero live imports outside the React tree.+- `pnpm fix && type-check && test --run && check` — all green.++## 5. Per-phase checklist++### Phase 1 — TabList leaves+- [ ] `TabItem/AdminLabel.tsx`+- [ ] `TabItem/Prefix.tsx`+- [ ] `TabItem/Suffix.tsx`+- [ ] `TabItem/Label.tsx` + test+- [ ] i18n keys ported (rename prompt, close confirm)+- [ ] Gates green++### Phase 2 — TabList+- [ ] `TabList.tsx` + dnd-kit wiring + test+- [ ] `TabItem.tsx` + test+- [ ] `TabContextMenu.tsx` + test+- [ ] `SQLEditorHomePage.vue` swap to `<ReactPageMount page="TabList" ... />`+- [ ] Delete Vue `TabList/*` files + `TabList/index.ts`+- [ ] Gates green++### Phase 3 — Connection tree nodes + HoverPanel+- [x] Per-node `.tsx` files + shared `Label.tsx` + test+- [x] `DatabaseHoverPanel.tsx` + `hover-state.ts` + test+- [x] Gates green+- [-] `ConnectionPane/tree.ts` — deferred to Phase 4 (Vue composable, not pure TS; coupled to ConnectionPane consumer)++### Phase 4a — Cheap leaves+- [x] `DatabaseGroupTag.tsx` + test+- [x] `tree.ts` React hook (`useSQLEditorTreeByEnvironment`)+- [x] Gates green++### Phase 4b — Context menu + FeatureModal+- [x] `actions.tsx` React port — `setConnection()` + `useConnectionMenu()`+- [x] `ConnectionContextMenu.tsx` imperative handle+- [x] `feature-modal.tsx` UI primitive+- [x] Tests + 6 i18n keys across 5 locales+- [x] Gates green++### Phase 4c — DatabaseGroup data table+- [x] `DatabaseGroupDataTable.tsx` (shared React component; `showActions` dropdown variant deferred to when a non-SQL-Editor caller ports)+- [x] `DatabaseGroupTable.tsx` (SQL Editor wrapper, inline `useDBGroupListByProject` via React hooks)+- [x] Tests (DataTable 6, Table 2)+- [x] Gates green++### Phase 4d — ConnectionPane shell + caller swap+- [x] `ConnectionPane.tsx` + 5 tests (+ 8 new i18n keys)+- [x] Gates green+- [-] AdvancedSearch scope chips (label / engine / instance / project filters) — deferred; React port uses `SearchInput` free-text only for now. Tracked as Phase 4e follow-up.+- [ ] Swap `ConnectionPanel.vue`'s `<ConnectionPane>` → `<ReactPageMount page="ConnectionPane" />` (Phase 5)+- [ ] Delete Vue `ConnectionPane/*.vue` + `actions.tsx` + `tree.ts` + `DatabaseHoverPanel/*` + `TreeNode/*` + `index.ts` (Phase 5)++### Phase 5 — Shell + cleanup+- [x] `ConnectionPanel.tsx` + 5 tests (shadcn Sheet, wide tier)+- [x] Swap `SQLEditorHomePage.vue` caller+- [x] Delete entire Vue `ConnectionPanel/` tree (ConnectionPanel.vue, ConnectionPane/*, TreeNode/*, DatabaseHoverPanel/*, actions.tsx, tree.ts, DatabaseGroupTag.vue, DatabaseGroupTable.vue, index.ts files)+- [x] `grep` confirms zero live Vue callers+- [x] Gates green + 1 new i18n key (`sql-editor.manage-connections`) across 5 locales++## 6. Manual UX verification (after all phases)++1. Open SQL editor → tabs render; the active tab is highlighted.+2. Click a tab → it becomes active; the editor content swaps.+3. Drag a tab → order persists in pinia store.+4. Right-click a tab → context menu shows; "Close others" leaves only the clicked tab.+5. Click the "+" button → a new unconnected tab opens with focus.+6. Mid-click a tab → it closes.+7. Click "Select a database to start" / "Connect to database" → ConnectionPanel drawer slides in from the right at ~800px width.+8. Panel renders instance tree grouped by environment label.+9. Hover on a database row for ~300ms → DatabaseHoverPanel appears with metadata.+10. Click a database → drawer closes, editor switches to that connection.+11. Enable batch-mode → multi-select checkboxes appear; selected databases surface as closable tags at the top.+12. Click a DatabaseGroupTag's close → group is removed from the tab's `batchQueryContext`.+13. Keyboard: Esc closes the drawer.++## 7. Out of scope (deferred)++- `SQLEditorHomePage.vue` migration (root container; depends on all children being React).+- `SchemaPane/*` — separate stage.+- `ResultView/VirtualDataTable/*` — separate stage; needs perf spike first.+- `EditorPanel.vue`, `Panels/*` (TablesPanel / ViewsPanel / etc.) — separate stage.++## 8. Risks & open questions++- **`@dnd-kit` perf at 30+ tabs:** users routinely open many tabs. The dnd-kit sortable is well-optimized but we should spot-check in Phase 2 with 30–50 tabs.+- **`NTree` behavior gaps:** our React `Tree` primitive was tuned for worksheet-size trees (hundreds of rows). ConnectionPane could surface 10k+ databases. Phase 3 will benchmark; if react-arborist's virtualization isn't sufficient, fall back to a simpler virtualization. Note: only the database-level leaves need virtualization; instances/environments are ≤200 nodes.+- **`usePreventBackAndForward`:** TabList binds this globally; verify only-one-installer wins so the React mount doesn't duplicate listeners.+- **`vue-draggable-plus` attribute parity:** the Vue component has `ghost-class="ghost"` styling during drag. Need equivalent ghost-state styling in dnd-kit's DragOverlay.+- **`RichDatabaseName`:** Vue-only. Options: (a) port a minimal React `RichDatabaseName` helper now (since ConnectionPanel and probably SchemaPane both need it), (b) inline a smaller display (engine icon + title) locally for Stage 14 and refactor later. Prefer (a) — lands as a small shared component in `src/react/components/RichDatabaseName.tsx`, reusable in Stage 15+.+- **`FeatureBadge`:** Used for the batch-query paywall. If a React version doesn't exist, mount via ReactPageMount OR port a minimal React version. Decide in Phase 4.diff --git a/frontend/src/layouts/SQLEditorLayout.vue b/frontend/src/layouts/SQLEditorLayout.vueindex 7ea3907b43..5e4998a4d5 100644--- a/frontend/src/layouts/SQLEditorLayout.vue+++ b/frontend/src/layouts/SQLEditorLayout.vue@@ -21,7 +21,6 @@ import { useEnvironmentV1Store, useSettingV1Store } from "@/store";import { Setting_SettingName } from "@/types/proto-es/v1/setting_service_pb";import { provideSQLEditorContext } from "@/views/sql-editor/context";import { provideSheetContext } from "@/views/sql-editor/Sheet";-import { provideTabListContext } from "@/views/sql-editor/TabList/context";const router = useRouter();@@ -29,8 +28,8 @@ const router = useRouter();provideSQLEditorContext();// provide context for sheetsprovideSheetContext();-// provide context for tabs-provideTabListContext();+// TabList no longer uses Vue provide/inject — React consumers import+// `tabListEvents` from `@/views/sql-editor/TabList/events` directly.const ready = ref(false);diff --git a/frontend/src/locales/en-US.json b/frontend/src/locales/en-US.jsonindex 7cf3f9e384..7915546d80 100644--- a/frontend/src/locales/en-US.json+++ b/frontend/src/locales/en-US.json@@ -2512,7 +2512,6 @@"copy-name": "Copy name","copy-selected-results": "Copy selected data by {action} or {button}","copy-url": "Copy URL",- "current-connection": "Current connection","download-as-file": "Download as {file}","duration-day": "{days} day","duration-days": "{days} days",@@ -2540,7 +2539,6 @@"loading-data": "Loading Data...","loading-databases": "Loading Databases...","manage-connections": "Manage connections",- "matched-in-group": "Matched in the database group: {title}","next-row": "Next Row","no-access-requests": "No access requests","no-data-available": "No data available",diff --git a/frontend/src/locales/es-ES.json b/frontend/src/locales/es-ES.jsonindex 1205c1ca9e..0942e42924 100644--- a/frontend/src/locales/es-ES.json+++ b/frontend/src/locales/es-ES.json@@ -2512,7 +2512,6 @@"copy-name": "Copiar nombre","copy-selected-results": "Copiar datos seleccionados por {action} o {button}","copy-url": "Copiar URL",- "current-connection": "Conexión actual","download-as-file": "Descargar como {file}","duration-day": "{days} day","duration-days": "{days} days",@@ -2540,7 +2539,6 @@"loading-data": "Cargando datos...","loading-databases": "Cargando bases de datos...","manage-connections": "Gestionar las conexiones",- "matched-in-group": "Coincidido en el grupo de base de datos: {title}","next-row": "siguiente fila","no-access-requests": "No access requests","no-data-available": "No hay datos disponibles",diff --git a/frontend/src/locales/ja-JP.json b/frontend/src/locales/ja-JP.jsonindex 3f7f0f3ebb..54708d110b 100644--- a/frontend/src/locales/ja-JP.json+++ b/frontend/src/locales/ja-JP.json@@ -2512,7 +2512,6 @@"copy-name": "名前をコピーする","copy-selected-results": "選択したデータを{action}または{button}でコピーします","copy-url": "URLをコピー",- "current-connection": "現在の接続","download-as-file": "{file} 形式でダウンロード","duration-day": "{days} day","duration-days": "{days} days",@@ -2540,7 +2539,6 @@"loading-data": "データのロード...","loading-databases": "データベース情報をロードしています...","manage-connections": "接続を管理する",- "matched-in-group": "データベース グループ {title} に一致しました","next-row": "次の行","no-access-requests": "No access requests","no-data-available": "データなし",diff --git a/frontend/src/locales/vi-VN.json b/frontend/src/locales/vi-VN.jsonindex e470811703..095701b36e 100644--- a/frontend/src/locales/vi-VN.json+++ b/frontend/src/locales/vi-VN.json@@ -2512,7 +2512,6 @@"copy-name": "Sao chép tên","copy-selected-results": "Sao chép dữ liệu đã chọn bằng {action} hoặc {button}","copy-url": "Sao chép URL",- "current-connection": "Kết nối hiện tại","download-as-file": "Tải xuống dưới dạng {file}","duration-day": "{days} day","duration-days": "{days} days",@@ -2540,7 +2539,6 @@"loading-data": "Đang tải Dữ liệu...","loading-databases": "Đang tải Cơ sở dữ liệu...","manage-connections": "Quản lý kết nối",- "matched-in-group": "Phù hợp trong nhóm cơ sở dữ liệu: {title}","next-row": "Dòng tiếp theo","no-access-requests": "No access requests","no-data-available": "Không có dữ liệu",diff --git a/frontend/src/locales/zh-CN.json b/frontend/src/locales/zh-CN.jsonindex 7ec4070e4b..9271b6f646 100644--- a/frontend/src/locales/zh-CN.json+++ b/frontend/src/locales/zh-CN.json@@ -2512,7 +2512,6 @@"copy-name": "复制名称","copy-selected-results": "通过 {action} 或 {button} 来快速复制选定的数据","copy-url": "复制 URL",- "current-connection": "当前连接","download-as-file": "下载为 {file} 格式","duration-day": "{days} 天","duration-days": "{days} 天",@@ -2540,7 +2539,6 @@"loading-data": "加载数据中...","loading-databases": "加载数据库信息...","manage-connections": "管理连接",- "matched-in-group": "在数据库组 {title} 中匹配","next-row": "下一行","no-access-requests": "暂无访问请求","no-data-available": "暂无数据",diff --git a/frontend/src/react/ReactPageMount.vue b/frontend/src/react/ReactPageMount.vueindex 534254b205..f9ce720850 100644--- a/frontend/src/react/ReactPageMount.vue+++ b/frontend/src/react/ReactPageMount.vue@@ -41,15 +41,41 @@ const pageProps = computed(() => {});let currentPage = "";+let unmounted = false;+// Serialization queue. `render()` is async and the dynamic imports yield+// for several event-loop ticks, so without serialization a watcher firing+// during the initial mount can race the onMounted call. Both pass the+// `if (!root)` guard, both call `mountReactPage`, and React ends up with+// two roots on the same container — the second mount silently uses stale+// props captured by the first call. Symptom: the first click of a Vue+// → React boolean toggle right after page refresh appears to do nothing+// because `open=true` from the watcher gets clobbered by the in-flight+// mount that captured `open=false`.+let renderQueue: Promise<void> = Promise.resolve();-async function render() {- if (!container.value) return;+function render(): Promise<void> {+ const next = renderQueue.then(() => doRender());+ // Catch on the chain we keep, so a rejection from one render doesn't+ // permanently break the queue. The original promise is still returned+ // to callers that may want to await it.+ renderQueue = next.catch(() => undefined);+ return next;+}++async function doRender() {+ if (unmounted || !container.value) return;const [{ mountReactPage, updateReactPage }, i18nModule] = await Promise.all([import("./mount"),import("./i18n"),]);+ // Re-check after the dynamic imports — Close All / tab-switch can unmount+ // this component while the imports are in flight. Without the guard,+ // `container.value` may be `undefined` by the time we call createRoot,+ // producing "Target container is not a DOM element".+ if (unmounted || !container.value) return;if (i18nModule.default.language !== locale.value) {await i18nModule.default.changeLanguage(locale.value);+ if (unmounted || !container.value) return;}// When the page component changes, unmount old root and create a fresh one// to avoid stale React state from the previous page.@@ -59,6 +85,11 @@ async function render() {}if (!root) {root = await mountReactPage(container.value, props.page, pageProps.value);+ if (unmounted) {+ root?.unmount();+ root = null;+ return;+ }} else {await updateReactPage(root, props.page, pageProps.value);}@@ -69,6 +100,7 @@ onMounted(() => render());watch(locale, () => render());watch([() => props.page, pageProps], () => render());onUnmounted(() => {+ unmounted = true;root?.unmount();root = null;});diff --git a/frontend/src/react/components/DatabaseGroupDataTable.test.tsx b/frontend/src/react/components/DatabaseGroupDataTable.test.tsxnew file mode 100644index 0000000000..b37c4cca4c--- /dev/null+++ b/frontend/src/react/components/DatabaseGroupDataTable.test.tsx@@ -0,0 +1,174 @@+import { act, type ReactElement } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { DatabaseGroup } from "@/types/proto-es/v1/database_group_service_pb";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("@/router", () => ({+ router: { resolve: vi.fn(() => ({ fullPath: "/x" })) },+}));++vi.mock("@/router/dashboard/projectV1", () => ({+ PROJECT_V1_ROUTE_DATABASE_GROUP_DETAIL: "project.dbgroup.detail",+}));++vi.mock("@/store", () => ({+ getProjectNameAndDatabaseGroupName: (name: string) => name.split("/"),+}));++let DatabaseGroupDataTable: typeof import("./DatabaseGroupDataTable").DatabaseGroupDataTable;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeGroup = (overrides: Partial<DatabaseGroup>): DatabaseGroup =>+ ({+ name: overrides.name ?? "projects/p/databaseGroups/g",+ title: overrides.title ?? "G",+ databaseExpr: overrides.databaseExpr,+ }) as DatabaseGroup;++beforeEach(async () => {+ ({ DatabaseGroupDataTable } = await import("./DatabaseGroupDataTable"));+});++describe("DatabaseGroupDataTable", () => {+ test("renders a row per group with title + expression", () => {+ const groups = [+ makeGroup({+ name: "projects/p/databaseGroups/a",+ title: "A",+ databaseExpr: {+ expression: "env == 'prod'",+ } as DatabaseGroup["databaseExpr"],+ }),+ makeGroup({+ name: "projects/p/databaseGroups/b",+ title: "B",+ databaseExpr: { expression: "" } as DatabaseGroup["databaseExpr"],+ }),+ ];+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupDataTable databaseGroupList={groups} />+ );+ render();+ expect(container.textContent).toContain("A");+ expect(container.textContent).toContain("env == 'prod'");+ expect(container.textContent).toContain("B");+ // Empty expression → common.empty placeholder+ expect(container.textContent).toContain("common.empty");+ unmount();+ });++ test("shows loading state when loading + empty list", () => {+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupDataTable databaseGroupList={[]} loading />+ );+ render();+ expect(container.textContent).toContain("common.loading");+ unmount();+ });++ test("shows no-data when list is empty and not loading", () => {+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupDataTable databaseGroupList={[]} />+ );+ render();+ expect(container.textContent).toContain("common.no-data");+ unmount();+ });++ test("checkbox toggles selection (multi-select mode)", () => {+ const groups = [+ makeGroup({ name: "projects/p/databaseGroups/a", title: "A" }),+ ];+ const onChange = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupDataTable+ databaseGroupList={groups}+ showSelection+ onSelectedDatabaseGroupNamesChange={onChange}+ />+ );+ render();+ const cb = container.querySelector(+ "input[type='checkbox']"+ ) as HTMLInputElement;+ act(() => {+ cb.click();+ });+ expect(onChange).toHaveBeenCalledWith(["projects/p/databaseGroups/a"]);+ unmount();+ });++ test("row click fires onRowClick with group", () => {+ const group = makeGroup({+ name: "projects/p/databaseGroups/a",+ title: "A",+ });+ const onRowClick = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupDataTable+ databaseGroupList={[group]}+ onRowClick={onRowClick}+ />+ );+ render();+ const row = container.querySelector("tbody tr") as HTMLElement;+ act(() => {+ row.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(onRowClick).toHaveBeenCalledTimes(1);+ expect(onRowClick.mock.calls[0][1]).toBe(group);+ unmount();+ });++ test("external-link column opens a new tab (does not trigger row click)", () => {+ const onRowClick = vi.fn();+ const openSpy = vi.spyOn(window, "open").mockImplementation(() => null);+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupDataTable+ databaseGroupList={[+ makeGroup({ name: "projects/p/databaseGroups/a", title: "A" }),+ ]}+ showExternalLink+ onRowClick={onRowClick}+ />+ );+ render();+ const linkBtn = container.querySelector(+ "button[aria-label='common.view-details']"+ ) as HTMLButtonElement;+ act(() => {+ linkBtn.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(openSpy).toHaveBeenCalledWith("/x", "_blank");+ expect(onRowClick).not.toHaveBeenCalled();+ openSpy.mockRestore();+ unmount();+ });+});diff --git a/frontend/src/react/components/DatabaseGroupDataTable.tsx b/frontend/src/react/components/DatabaseGroupDataTable.tsxnew file mode 100644index 0000000000..3d32aff5be--- /dev/null+++ b/frontend/src/react/components/DatabaseGroupDataTable.tsx@@ -0,0 +1,288 @@+import { EllipsisVertical, ExternalLink } from "lucide-react";+import { useCallback, useEffect, useMemo, useState } from "react";+import { useTranslation } from "react-i18next";+import { Button } from "@/react/components/ui/button";+import {+ DropdownMenu,+ DropdownMenuContent,+ DropdownMenuItem,+ DropdownMenuTrigger,+} from "@/react/components/ui/dropdown-menu";+import {+ Table,+ TableBody,+ TableCell,+ TableHead,+ TableHeader,+ TableRow,+} from "@/react/components/ui/table";+import { cn } from "@/react/lib/utils";+import { router } from "@/router";+import { PROJECT_V1_ROUTE_DATABASE_GROUP_DETAIL } from "@/router/dashboard/projectV1";+import { getProjectNameAndDatabaseGroupName } from "@/store";+import type { DatabaseGroup } from "@/types/proto-es/v1/database_group_service_pb";++type Props = {+ readonly databaseGroupList: DatabaseGroup[];+ readonly loading?: boolean;+ readonly showSelection?: boolean;+ readonly showExternalLink?: boolean;+ readonly showActions?: boolean;+ readonly singleSelection?: boolean;+ readonly selectedDatabaseGroupNames?: string[];+ readonly onSelectedDatabaseGroupNamesChange?: (names: string[]) => void;+ readonly onRowClick?: (e: React.MouseEvent, group: DatabaseGroup) => void;+ readonly onDelete?: (group: DatabaseGroup) => void;+ /** Client-side pagination size. `0` or undefined disables pagination. */+ readonly pageSize?: number;+};++/**+ * Replaces frontend/src/components/DatabaseGroup/DatabaseGroupDataTable.vue.+ * Shared React port. Columns — in order — are: optional selection, title,+ * expression, optional external-link, optional actions (kebab menu with+ * Delete). Supports optional client-side pagination for the "manage+ * groups" admin use case.+ */+export function DatabaseGroupDataTable({+ databaseGroupList,+ loading,+ showSelection,+ showExternalLink,+ showActions,+ singleSelection,+ selectedDatabaseGroupNames = [],+ onSelectedDatabaseGroupNamesChange,+ onRowClick,+ onDelete,+ pageSize = 0,+}: Props) {+ const { t } = useTranslation();+ const [page, setPage] = useState(0);++ // Reset paging whenever the underlying list shrinks/grows so we never+ // land on an out-of-range page.+ useEffect(() => {+ setPage(0);+ }, [databaseGroupList.length]);++ const totalPages =+ pageSize > 0 ? Math.ceil(databaseGroupList.length / pageSize) : 1;+ const visibleList = useMemo(() => {+ if (pageSize <= 0) return databaseGroupList;+ return databaseGroupList.slice(page * pageSize, (page + 1) * pageSize);+ }, [databaseGroupList, page, pageSize]);++ const selectedSet = useMemo(+ () => new Set(selectedDatabaseGroupNames),+ [selectedDatabaseGroupNames]+ );++ const toggleSingle = useCallback(+ (name: string, checked: boolean) => {+ if (!onSelectedDatabaseGroupNamesChange) return;+ if (singleSelection) {+ onSelectedDatabaseGroupNamesChange(checked ? [name] : []);+ return;+ }+ const next = new Set(selectedSet);+ if (checked) {+ next.add(name);+ } else {+ next.delete(name);+ }+ onSelectedDatabaseGroupNamesChange([...next]);+ },+ [onSelectedDatabaseGroupNamesChange, selectedSet, singleSelection]+ );++ const handleRowClick = (e: React.MouseEvent, group: DatabaseGroup) => {+ if (onRowClick) {+ onRowClick(e, group);+ return;+ }+ const isSelected = selectedSet.has(group.name);+ toggleSingle(group.name, !isSelected);+ };++ const handleExternalLink = (e: React.MouseEvent, group: DatabaseGroup) => {+ e.stopPropagation();+ const [projectId, databaseGroupName] = getProjectNameAndDatabaseGroupName(+ group.name+ );+ const route = router.resolve({+ name: PROJECT_V1_ROUTE_DATABASE_GROUP_DETAIL,+ params: {+ projectId,+ databaseGroupName,+ },+ });+ window.open(route.fullPath, "_blank");+ };++ const colCount =+ 1 /* title */ ++ 1 /* expression */ ++ (showSelection ? 1 : 0) ++ (showExternalLink ? 1 : 0) ++ (showActions ? 1 : 0);++ return (+ <div className="flex flex-col gap-y-3">+ <div className="border rounded-sm">+ <div className="overflow-x-auto">+ <Table>+ <TableHeader>+ <TableRow className="bg-gray-50">+ {showSelection && <TableHead className="w-10" />}+ <TableHead className="w-64">{t("common.name")}</TableHead>+ <TableHead>{t("database.expression")}</TableHead>+ {showExternalLink && <TableHead className="w-12" />}+ {showActions && <TableHead className="w-12" />}+ </TableRow>+ </TableHeader>+ <TableBody>+ {loading && databaseGroupList.length === 0 ? (+ <TableRow>+ <TableCell+ colSpan={colCount}+ className="py-8 text-center text-control-placeholder"+ >+ <div className="flex items-center justify-center gap-x-2">+ <div className="animate-spin h-4 w-4 border-2 border-accent border-t-transparent rounded-full" />+ {t("common.loading")}+ </div>+ </TableCell>+ </TableRow>+ ) : databaseGroupList.length === 0 ? (+ <TableRow>+ <TableCell+ colSpan={colCount}+ className="py-8 text-center text-control-placeholder"+ >+ {t("common.no-data")}+ </TableCell>+ </TableRow>+ ) : (+ visibleList.map((group) => {+ const isSelected = selectedSet.has(group.name);+ return (+ <TableRow+ key={group.name}+ className={cn("cursor-pointer")}+ data-state={isSelected ? "selected" : undefined}+ onClick={(e) => handleRowClick(e, group)}+ >+ {showSelection && (+ <TableCell onClick={(e) => e.stopPropagation()}>+ <input+ type={singleSelection ? "radio" : "checkbox"}+ className="rounded-xs border-control-border"+ checked={isSelected}+ onChange={(e) =>+ toggleSingle(group.name, e.target.checked)+ }+ />+ </TableCell>+ )}+ <TableCell className="max-w-[16rem] truncate">+ {group.title}+ </TableCell>+ <TableCell className="truncate">+ {group.databaseExpr?.expression ? (+ group.databaseExpr.expression+ ) : (+ <span className="italic text-control-placeholder">+ {t("common.empty")}+ </span>+ )}+ </TableCell>+ {showExternalLink && (+ <TableCell>+ <button+ type="button"+ className={cn(+ "flex items-center justify-end cursor-pointer size-6 p-1 opacity-60",+ "hover:opacity-100 hover:bg-white hover:shadow-xs rounded-sm"+ )}+ onClick={(e) => handleExternalLink(e, group)}+ aria-label={t("common.view-details")}+ >+ <ExternalLink className="size-4" />+ </button>+ </TableCell>+ )}+ {showActions && (+ <TableCell onClick={(e) => e.stopPropagation()}>+ <ActionDropdown group={group} onDelete={onDelete} />+ </TableCell>+ )}+ </TableRow>+ );+ })+ )}+ </TableBody>+ </Table>+ </div>+ </div>++ {pageSize > 0 && totalPages > 1 && (+ <div className="flex justify-end items-center gap-x-2">+ <Button+ variant="outline"+ size="sm"+ disabled={page === 0}+ onClick={() => setPage((p) => Math.max(0, p - 1))}+ >+ {t("common.previous")}+ </Button>+ <span className="text-sm text-control-light">+ {page + 1} / {totalPages}+ </span>+ <Button+ variant="outline"+ size="sm"+ disabled={page >= totalPages - 1}+ onClick={() => setPage((p) => Math.min(totalPages - 1, p + 1))}+ >+ {t("common.next")}+ </Button>+ </div>+ )}+ </div>+ );+}++function ActionDropdown({+ group,+ onDelete,+}: {+ group: DatabaseGroup;+ onDelete?: (group: DatabaseGroup) => void;+}) {+ const { t } = useTranslation();+ return (+ <div className="flex justify-end">+ <DropdownMenu>+ <DropdownMenuTrigger+ className="p-1 rounded-xs hover:bg-control-bg outline-hidden"+ onClick={(e) => e.stopPropagation()}+ aria-label={t("common.actions")}+ >+ <EllipsisVertical className="size-4" />+ </DropdownMenuTrigger>+ <DropdownMenuContent>+ <DropdownMenuItem+ className="text-error"+ onClick={(e) => {+ e.stopPropagation();+ onDelete?.(group);+ }}+ >+ {t("common.delete")}+ </DropdownMenuItem>+ </DropdownMenuContent>+ </DropdownMenu>+ </div>+ );+}diff --git a/frontend/src/react/components/DatabaseGroupTable.tsx b/frontend/src/react/components/DatabaseGroupTable.tsxnew file mode 100644index 0000000000..a7a748b076--- /dev/null+++ b/frontend/src/react/components/DatabaseGroupTable.tsx@@ -0,0 +1,146 @@+import type { ReactNode } from "react";+import { useEffect, useMemo, useState } from "react";+import { useTranslation } from "react-i18next";+import { DatabaseGroupDataTable } from "@/react/components/DatabaseGroupDataTable";+import { SearchInput } from "@/react/components/ui/search-input";+import { useDBGroupStore } from "@/store/modules";+import type { DatabaseGroup } from "@/types/proto-es/v1/database_group_service_pb";+import { DatabaseGroupView } from "@/types/proto-es/v1/database_group_service_pb";++type Props = {+ readonly projectName: string;+ readonly view: DatabaseGroupView;+ /** Leading caption shown to the left of the search box. */+ readonly leadingLabel?: string;+ /** Optional element rendered to the right of the search box (e.g. Create). */+ readonly trailingAction?: ReactNode;+ // --- DataTable forwards ---+ readonly showSelection?: boolean;+ readonly showExternalLink?: boolean;+ readonly showActions?: boolean;+ readonly singleSelection?: boolean;+ readonly selectedDatabaseGroupNames?: string[];+ readonly onSelectedDatabaseGroupNamesChange?: (names: string[]) => void;+ readonly onRowClick?: (e: React.MouseEvent, group: DatabaseGroup) => void;+ readonly onDelete?: (group: DatabaseGroup) => void;+ readonly pageSize?: number;+ /**+ * Controls who owns the fetched list. When set, the wrapper skips its+ * internal fetch and renders whatever the caller passes. Use this when+ * the page already owns the list (e.g. needs to mutate it after delete).+ */+ readonly externalList?: DatabaseGroup[];+ readonly externalLoading?: boolean;+ readonly searchPlaceholder?: string;+};++/**+ * Shared wrapper: SearchInput + `DatabaseGroupDataTable`. Either:+ * - owns the fetch (default — used by SQL Editor ConnectionPane); or+ * - renders `externalList` verbatim (used by pages that already manage+ * the list state, e.g. to remove a row after delete without refetching).+ *+ * All selection / action / pagination concerns are delegated to the inner+ * `DatabaseGroupDataTable`.+ */+export function DatabaseGroupTable({+ projectName,+ view,+ leadingLabel,+ trailingAction,+ showSelection,+ showExternalLink,+ showActions,+ singleSelection,+ selectedDatabaseGroupNames,+ onSelectedDatabaseGroupNamesChange,+ onRowClick,+ onDelete,+ pageSize,+ externalList,+ externalLoading,+ searchPlaceholder,+}: Props) {+ const { t } = useTranslation();+ const dbGroupStore = useDBGroupStore();++ const [search, setSearch] = useState("");+ const [internalList, setInternalList] = useState<DatabaseGroup[]>([]);+ const [internalReady, setInternalReady] = useState(false);++ // Only fetch when an external list is not provided.+ useEffect(() => {+ if (externalList !== undefined) return;+ let cancelled = false;+ setInternalReady(false);+ setInternalList([]);+ void dbGroupStore+ .fetchDBGroupListByProjectName(projectName, view)+ .then((groups) => {+ if (cancelled) return;+ setInternalList(groups);+ setInternalReady(true);+ });+ return () => {+ cancelled = true;+ };+ }, [dbGroupStore, projectName, view, externalList]);++ const sourceList = externalList ?? internalList;+ const loading =+ externalList !== undefined ? !!externalLoading : !internalReady;++ const filtered = useMemo(() => {+ const query = search.trim().toLowerCase();+ if (!query) return sourceList;+ return sourceList.filter(+ (g) =>+ g.name.toLowerCase().includes(query) ||+ g.title.toLowerCase().includes(query)+ );+ }, [sourceList, search]);++ return (+ <div className="flex flex-col gap-y-3">+ {(leadingLabel || trailingAction) && (+ <div className="w-full flex flex-row justify-between items-center gap-x-2">+ {leadingLabel ? (+ <p className="text-control-light text-sm">{leadingLabel}</p>+ ) : (+ <span />+ )}+ <div className="flex items-center gap-x-2">+ <SearchInput+ value={search}+ onChange={(e) => setSearch(e.target.value)}+ placeholder={searchPlaceholder ?? t("common.filter-by-name")}+ wrapperClassName="max-w-[16rem]"+ />+ {trailingAction}+ </div>+ </div>+ )}+ {!leadingLabel && !trailingAction && (+ <SearchInput+ value={search}+ onChange={(e) => setSearch(e.target.value)}+ placeholder={searchPlaceholder ?? t("common.filter-by-name")}+ wrapperClassName="max-w-[16rem]"+ />+ )}+ <DatabaseGroupDataTable+ databaseGroupList={filtered}+ loading={loading}+ showSelection={showSelection}+ showExternalLink={showExternalLink}+ showActions={showActions}+ singleSelection={singleSelection}+ selectedDatabaseGroupNames={selectedDatabaseGroupNames}+ onSelectedDatabaseGroupNamesChange={onSelectedDatabaseGroupNamesChange}+ onRowClick={onRowClick}+ onDelete={onDelete}+ pageSize={pageSize}+ />+ </div>+ );+}diff --git a/frontend/src/react/components/FeatureBadge.tsx b/frontend/src/react/components/FeatureBadge.tsxindex 42cbe3496c..f688843a93 100644--- a/frontend/src/react/components/FeatureBadge.tsx+++ b/frontend/src/react/components/FeatureBadge.tsx@@ -1,4 +1,5 @@import { Lock, Sparkles } from "lucide-react";+import type { ReactNode } from "react";import { useTranslation } from "react-i18next";import { useVueState } from "@/react/hooks/useVueState";import { useSubscriptionV1Store } from "@/store";@@ -17,6 +18,13 @@ interface FeatureBadgeProps {readonly instance?: Instance | InstanceResource;readonly clickable?: boolean;readonly className?: string;+ /**+ * Rendered in place of the badge when the feature IS available (and the+ * instance has its license). Lets callers express "show this content+ * icon when granted; replace it with the paywall sparkles when gated"+ * in a single component, instead of stacking both icons in a Button.+ */+ readonly fallback?: ReactNode;}const planLabel: Record<number, string> = {@@ -37,6 +45,7 @@ export function FeatureBadge({instance,clickable = true,className,+ fallback = null,}: FeatureBadgeProps) {const { t } = useTranslation();const subscriptionStore = useSubscriptionV1Store();@@ -66,7 +75,7 @@ export function FeatureBadge({}if (hasFeature) {- return null;+ return <>{fallback}</>;}const requiredPlanLabel = t(diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionContextMenu.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionContextMenu.test.tsxnew file mode 100644index 0000000000..1e1a225ea5--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionContextMenu.test.tsx@@ -0,0 +1,136 @@+import { act, createRef, type ReactElement } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTreeNode } from "@/types";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const mocks = vi.hoisted(() => ({+ useConnectionMenu: vi.fn(),+ handleSelect: vi.fn(),+}));++vi.mock("./actions", () => ({+ useConnectionMenu: mocks.useConnectionMenu,+}));++vi.mock("@/react/components/ui/dropdown-menu", () => ({+ DropdownMenu: ({ children }: { children: React.ReactNode }) => (+ <div data-testid="dropdown-menu">{children}</div>+ ),+ DropdownMenuContent: ({ children }: { children: React.ReactNode }) => (+ <div data-testid="dropdown-content">{children}</div>+ ),+ DropdownMenuItem: ({+ children,+ onClick,+ }: {+ children: React.ReactNode;+ onClick?: () => void;+ }) => (+ <button data-testid="dropdown-item" onClick={onClick} type="button">+ {children}+ </button>+ ),+ DropdownMenuTrigger: ({+ ref,+ ...rest+ }: {+ ref?: React.Ref<HTMLButtonElement>;+ } & React.HTMLAttributes<HTMLButtonElement>) => (+ <button ref={ref} data-testid="dropdown-trigger" {...rest} />+ ),+}));++let ConnectionContextMenu: typeof import("./ConnectionContextMenu").ConnectionContextMenu;+type Handle = import("./ConnectionContextMenu").ConnectionContextMenuHandle;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeNode = (): SQLEditorTreeNode =>+ ({+ key: "databases/bb",+ meta: {+ type: "database",+ target: { name: "instances/prod/databases/bb" },+ },+ }) as unknown as SQLEditorTreeNode;++beforeEach(async () => {+ vi.clearAllMocks();+ ({ ConnectionContextMenu } = await import("./ConnectionContextMenu"));+});++describe("ConnectionContextMenu", () => {+ test("renders null when the connection menu has no items", () => {+ mocks.useConnectionMenu.mockReturnValue({+ items: [],+ handleSelect: mocks.handleSelect,+ });+ const ref = createRef<Handle>();+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionContextMenu ref={ref} />+ );+ render();+ expect(container.textContent).toBe("");+ unmount();+ });++ test("renders one item per hook result + clicking invokes handleSelect with the key", () => {+ mocks.useConnectionMenu.mockReturnValue({+ items: [+ { key: "connect", label: "Connect", icon: null, onSelect: vi.fn() },+ {+ key: "view-database-detail",+ label: "View",+ icon: null,+ onSelect: vi.fn(),+ },+ ],+ handleSelect: mocks.handleSelect,+ });+ const ref = createRef<Handle>();+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionContextMenu ref={ref} />+ );+ render();+ // Force a show to pass a node to the hook.+ act(() => {+ ref.current?.show(makeNode(), {+ preventDefault: () => {},+ stopPropagation: () => {},+ clientX: 10,+ clientY: 20,+ } as React.MouseEvent);+ });+ const items = container.querySelectorAll("[data-testid='dropdown-item']");+ expect(items.length).toBe(2);+ act(() => {+ (items[0] as HTMLButtonElement).dispatchEvent(+ new MouseEvent("click", { bubbles: true })+ );+ });+ expect(mocks.handleSelect).toHaveBeenCalledWith("connect");+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionContextMenu.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionContextMenu.tsxnew file mode 100644index 0000000000..63d11b2090--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionContextMenu.tsx@@ -0,0 +1,103 @@+import { forwardRef, useImperativeHandle, useRef, useState } from "react";+import { flushSync } from "react-dom";+import {+ DropdownMenu,+ DropdownMenuContent,+ DropdownMenuItem,+ DropdownMenuTrigger,+} from "@/react/components/ui/dropdown-menu";+import type { SQLEditorTreeNode } from "@/types";+import { useConnectionMenu } from "./actions";++export type ConnectionContextMenuHandle = {+ show: (node: SQLEditorTreeNode, e: React.MouseEvent) => void;+ hide: () => void;+};++type Target = {+ x: number;+ y: number;+ node: SQLEditorTreeNode;+};++/**+ * Replaces the `NDropdown placement="bottom-start" trigger="manual"` in+ * frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/ConnectionPane.vue.+ * Mirrors the TabContextMenu pattern: a 0×0 position-fixed trigger at the+ * cursor is programmatically .click()-ed so Base UI records a click-type+ * open event and the popup stays open when the pointer moves onto items.+ */+export const ConnectionContextMenu = forwardRef<ConnectionContextMenuHandle>(+ function ConnectionContextMenu(_, ref) {+ const [target, setTarget] = useState<Target | null>(null);+ const triggerRef = useRef<HTMLButtonElement>(null);++ const { items, handleSelect } = useConnectionMenu(target?.node ?? null);++ useImperativeHandle(+ ref,+ () => ({+ show(node, e) {+ e.preventDefault();+ e.stopPropagation();+ flushSync(() => {+ setTarget({ x: e.clientX, y: e.clientY, node });+ });+ triggerRef.current?.click();+ },+ hide() {+ setTarget(null);+ },+ }),+ []+ );++ if (items.length === 0) {+ // Nothing to show for this node (disabled, or an unsupported type).+ return null;+ }++ return (+ <DropdownMenu+ onOpenChange={(open) => {+ if (!open) setTarget(null);+ }}+ >+ <DropdownMenuTrigger+ ref={triggerRef}+ aria-hidden+ tabIndex={-1}+ style={{+ position: "fixed",+ top: target?.y ?? 0,+ left: target?.x ?? 0,+ width: 0,+ height: 0,+ pointerEvents: "none",+ opacity: 0,+ }}+ />+ <DropdownMenuContent+ align="start"+ sideOffset={4}+ positionMethod="fixed"+ >+ {items.map((item) => (+ <DropdownMenuItem+ key={item.key}+ onClick={() => {+ handleSelect(item.key);+ setTarget(null);+ }}+ >+ <span className="inline-flex items-center gap-x-2">+ {item.icon}+ {item.label}+ </span>+ </DropdownMenuItem>+ ))}+ </DropdownMenuContent>+ </DropdownMenu>+ );+ }+);diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionPane.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionPane.test.tsxnew file mode 100644index 0000000000..511f2cb45b--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionPane.test.tsx@@ -0,0 +1,447 @@+import { act, type ReactElement } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++globalThis.ResizeObserver = class ResizeObserver {+ observe() {}+ unobserve() {}+ disconnect() {}+};++const mocks = vi.hoisted(() => {+ const tabStore = {+ supportBatchMode: true,+ isInBatchMode: false,+ currentTab: {+ id: "t-1",+ mode: "WORKSHEET" as const,+ title: "Untitled",+ connection: { database: "", instance: "" },+ batchQueryContext: {+ databases: [] as string[],+ databaseGroups: [] as string[],+ },+ },+ updateBatchQueryContext: vi.fn(),+ setCurrentTabId: vi.fn(),+ updateTab: vi.fn(),+ };+ const editorStore = {+ project: "projects/p",+ projectContextReady: true,+ allowAdmin: false,+ };+ const uiStore = { showConnectionPanel: true, asidePanelTab: "SCHEMA" };+ const databaseStore = {+ batchGetOrFetchDatabases: vi.fn().mockResolvedValue([]),+ getDatabaseByName: vi.fn(() => undefined),+ getOrFetchDatabaseByName: vi.fn().mockResolvedValue(undefined),+ };+ const dbGroupStore = {+ fetchDBGroupListByProjectName: vi.fn().mockResolvedValue([]),+ // The component reads `.name` and `.matchedDatabases` off the result+ // and validates `.name` via `isValidDatabaseGroupName`. Returning an+ // unknown-name placeholder preserves the "skip invalid" branch+ // without leaking real groups into tests that don't set them up.+ getDBGroupByName: vi.fn(() => ({+ name: "",+ matchedDatabases: [],+ title: "",+ })),+ getOrFetchDBGroupByName: vi.fn().mockResolvedValue(undefined),+ };+ const environmentStore = {+ environmentList: [+ {+ name: "environments/prod",+ title: "Prod",+ color: "",+ tags: {},+ },+ ],+ getEnvironmentByName: vi.fn((name: string) => ({+ name,+ title: name.split("/").pop() ?? name,+ color: "",+ tags: {},+ })),+ };+ const projectStore = {+ getProjectByName: vi.fn(() => ({+ name: "projects/p",+ title: "Project One",+ })),+ };+ const treeStore = {+ state: "READY" as "LOADING" | "READY" | "UNSET",+ nodeKeysByTarget: vi.fn(() => []),+ };+ const instanceStore = {+ getInstanceByName: vi.fn(),+ };+ const currentUser = { value: { email: "[email protected]" } };+ return {+ tabStore,+ editorStore,+ uiStore,+ databaseStore,+ dbGroupStore,+ environmentStore,+ projectStore,+ treeStore,+ instanceStore,+ currentUser,+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+ featureToRef: vi.fn(() => ({ value: true })),+ pushNotification: vi.fn(),+ };+});++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/store", () => ({+ featureToRef: mocks.featureToRef,+ pushNotification: mocks.pushNotification,+ useCurrentUserV1: () => mocks.currentUser,+ useDatabaseV1Store: () => mocks.databaseStore,+ useDBGroupStore: () => mocks.dbGroupStore,+ useEnvironmentV1Store: () => mocks.environmentStore,+ useInstanceV1Store: () => mocks.instanceStore,+ useProjectV1Store: () => mocks.projectStore,+ useSQLEditorStore: () => mocks.editorStore,+ useSQLEditorTabStore: () => mocks.tabStore,+ useSQLEditorTreeStore: () => mocks.treeStore,+ useSQLEditorUIStore: () => mocks.uiStore,+}));++vi.mock("@/store/modules", () => ({+ useDBGroupStore: () => mocks.dbGroupStore,+}));++vi.mock("@/store/modules/v1/common", () => ({+ instanceNamePrefix: "instances/",+}));++vi.mock("@/views/sql-editor/events", () => ({+ sqlEditorEvents: {+ emit: vi.fn(),+ on: vi.fn(() => () => {}),+ },+}));++vi.mock("@/types", () => ({+ isValidDatabaseGroupName: () => true,+ isValidDatabaseName: (name: string) => !!name,+ isValidProjectName: () => true,+ UNKNOWN_ENVIRONMENT_NAME: "environments/-1",+ NULL_ENVIRONMENT_NAME: "environments/-",+ unknownEnvironment: () => ({+ name: "environments/-1",+ title: "Unknown",+ color: "",+ tags: {},+ }),+}));++vi.mock("@/types/proto-es/v1/instance_service_pb", () => ({+ DataSourceType: { ADMIN: 1, READ_ONLY: 2 },+}));++vi.mock("@/types/proto-es/v1/subscription_service_pb", () => ({+ PlanFeature: {+ FEATURE_BATCH_QUERY: 1,+ FEATURE_DATABASE_GROUPS: 2,+ FEATURE_ENVIRONMENT_TIERS: 3,+ },+ PlanType: { FREE: 0, TEAM: 1, ENTERPRISE: 3 },+}));++vi.mock("@/types/proto-es/v1/database_group_service_pb", () => ({+ DatabaseGroupView: { FULL: 2 },+}));++vi.mock("@/utils", () => ({+ extractDatabaseResourceName: (n: string) => ({+ instance: "instances/x",+ databaseName: n.split("/").pop() ?? "",+ }),+ getConnectionForSQLEditorTab: () => ({ database: undefined }),+ getInstanceResource: () => ({ engine: "MYSQL" }),+ getValueFromSearchParams: () => "",+ getValuesFromSearchParams: () => [],+ instanceV1Name: (i: { title: string }) => i.title,+}));++vi.mock("@/components/InstanceForm/constants", () => ({+ EngineIconPath: { MYSQL: "/mysql.svg" },+}));++vi.mock("@/react/components/FeatureBadge", () => ({+ FeatureBadge: () => null,+}));++vi.mock("@/react/components/ui/feature-modal", () => ({+ FeatureModal: ({ open, feature }: { open: boolean; feature: unknown }) =>+ open && feature ? <div data-testid="feature-modal" /> : null,+}));++vi.mock("@/react/components/ui/radio-group", () => ({+ RadioGroup: ({ children }: { children: React.ReactNode }) => (+ <div data-testid="radio-group">{children}</div>+ ),+ RadioGroupItem: ({ children }: { children?: React.ReactNode }) => (+ <label>{children}</label>+ ),+}));++vi.mock("@/react/components/ui/separator", () => ({+ Separator: () => <hr data-testid="separator" />,+}));++vi.mock("@/react/components/AdvancedSearch", () => ({+ AdvancedSearch: () => <div data-testid="advanced-search" />,+ emptySearchParams: () => ({ query: "", scopes: [] }),+}));++vi.mock("@/react/components/useCommonSearchScopeOptions", () => ({+ useCommonSearchScopeOptions: () => [],+}));++vi.mock("@/react/components/ui/tabs", () => ({+ Tabs: ({+ value,+ onValueChange,+ children,+ }: {+ value: string;+ onValueChange: (v: string) => void;+ children: React.ReactNode;+ }) => (+ <div+ data-testid="tabs"+ data-value={value}+ onClick={(e) => {+ const t = (e.target as HTMLElement).dataset.tabValue;+ if (t) onValueChange(t);+ }}+ >+ {children}+ </div>+ ),+ TabsList: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+ TabsTrigger: ({+ value,+ children,+ disabled,+ }: {+ value: string;+ children: React.ReactNode;+ disabled?: boolean;+ }) => (+ <button+ type="button"+ data-testid={`tab-trigger-${value}`}+ data-tab-value={value}+ disabled={disabled}+ >+ {children}+ </button>+ ),+ TabsPanel: ({+ value,+ children,+ }: {+ value: string;+ children: React.ReactNode;+ }) => <div data-testid={`tab-panel-${value}`}>{children}</div>,+}));++vi.mock("@/react/components/ui/tooltip", () => ({+ Tooltip: ({ children }: { children: React.ReactNode }) => <>{children}</>,+}));++vi.mock("@/react/components/ui/tree", () => ({+ Tree: ({ data }: { data: unknown[] }) => (+ <div data-testid="tree" data-len={data.length} />+ ),+}));++vi.mock("./actions", () => ({+ setConnection: vi.fn(),+}));++vi.mock("./ConnectionContextMenu", () => ({+ ConnectionContextMenu: () => <div data-testid="context-menu" />,+}));++vi.mock("@/react/components/DatabaseGroupTable", () => ({+ DatabaseGroupTable: () => <div data-testid="db-group-table" />,+}));++vi.mock("./DatabaseGroupTag", () => ({+ DatabaseGroupTag: () => <div data-testid="db-group-tag" />,+}));++vi.mock("./DatabaseHoverPanel/DatabaseHoverPanel", () => ({+ DatabaseHoverPanel: () => <div data-testid="hover-panel" />,+}));++vi.mock("./DatabaseHoverPanel/hover-state", () => ({+ HoverStateProvider: ({ children }: { children: React.ReactNode }) => (+ <>{children}</>+ ),+ useHoverState: () => ({+ state: undefined,+ position: { x: 0, y: 0 },+ setPosition: vi.fn(),+ update: vi.fn(),+ }),+ useProvideHoverState: () => ({+ state: undefined,+ position: { x: 0, y: 0 },+ setPosition: vi.fn(),+ update: vi.fn(),+ }),+}));++vi.mock("./TreeNode/Label", () => ({+ Label: () => <div data-testid="tree-node-label" />,+}));++vi.mock("./tree", () => ({+ useSQLEditorTreeByEnvironment: () => ({+ tree: [],+ expandedState: { initialized: true, expandedKeys: [] },+ setExpandedKeys: vi.fn(),+ buildTree: vi.fn(),+ prepareDatabases: vi.fn().mockResolvedValue(undefined),+ fetchDatabases: vi.fn().mockResolvedValue(undefined),+ fetchDataState: { loading: false },+ }),+}));++let ConnectionPane: typeof import("./ConnectionPane").ConnectionPane;++const renderIntoContainer = (element: 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 () => {+ vi.clearAllMocks();+ mocks.useVueState.mockImplementation((getter) => getter());+ // Reset feature flags default to true for render-path tests.+ mocks.featureToRef.mockReturnValue({ value: true });+ mocks.tabStore.isInBatchMode = false;+ mocks.tabStore.currentTab = {+ id: "t-1",+ mode: "WORKSHEET",+ title: "Untitled",+ connection: { database: "", instance: "" },+ batchQueryContext: { databases: [], databaseGroups: [] },+ };+ ({ ConnectionPane } = await import("./ConnectionPane"));+});++describe("ConnectionPane", () => {+ test("renders DATABASE tab content when show=true and no selection", () => {+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPane show={true} onMissingFeature={() => {}} />+ );+ render();+ expect(+ container.querySelector("[data-testid='advanced-search']")+ ).not.toBeNull();+ expect(+ container+ .querySelector("[data-testid='tabs']")+ ?.getAttribute("data-value")+ ).toBe("DATABASE");+ unmount();+ });++ test("renders the batch-mode header when supportBatchMode is true", () => {+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPane show={true} onMissingFeature={() => {}} />+ );+ render();+ expect(container.textContent).toContain(+ "sql-editor.batch-query.description"+ );+ unmount();+ });++ test("mounts the context menu + hover panel + modal harness", () => {+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPane show={true} onMissingFeature={() => {}} />+ );+ render();+ expect(+ container.querySelector("[data-testid='context-menu']")+ ).not.toBeNull();+ expect(+ container.querySelector("[data-testid='hover-panel']")+ ).not.toBeNull();+ unmount();+ });++ test("switches to DATABASE-GROUP tab when only groups are selected on open", () => {+ mocks.tabStore.currentTab = {+ ...mocks.tabStore.currentTab,+ batchQueryContext: {+ databases: [],+ databaseGroups: ["projects/p/databaseGroups/g"],+ },+ };+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPane show={true} onMissingFeature={() => {}} />+ );+ render();+ expect(+ container+ .querySelector("[data-testid='tabs']")+ ?.getAttribute("data-value")+ ).toBe("DATABASE-GROUP");+ unmount();+ });++ test("disables DATABASE-GROUP tab when batch-query or database-group features missing", () => {+ mocks.featureToRef.mockImplementation(() => ({ value: false }));+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPane show={true} onMissingFeature={() => {}} />+ );+ render();+ const trigger = container.querySelector(+ "[data-testid='tab-trigger-DATABASE-GROUP']"+ ) as HTMLButtonElement;+ expect(trigger.disabled).toBe(true);+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionPane.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionPane.tsxnew file mode 100644index 0000000000..b738361a8d--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/ConnectionPane.tsx@@ -0,0 +1,1209 @@+import { cloneDeep } from "lodash-es";+import { ChevronDown, ChevronRight, Info, X } from "lucide-react";+import { useCallback, useEffect, useMemo, useRef, useState } from "react";+import { useTranslation } from "react-i18next";+import { EngineIconPath } from "@/components/InstanceForm/constants";+import {+ AdvancedSearch,+ emptySearchParams,+ type SearchParams,+} from "@/react/components/AdvancedSearch";+import { DatabaseGroupTable } from "@/react/components/DatabaseGroupTable";+import { FeatureBadge } from "@/react/components/FeatureBadge";+import { RadioGroup, RadioGroupItem } from "@/react/components/ui/radio-group";+import { Separator } from "@/react/components/ui/separator";+import {+ Tabs,+ TabsList,+ TabsPanel,+ TabsTrigger,+} from "@/react/components/ui/tabs";+import { Tooltip } from "@/react/components/ui/tooltip";+import { Tree, type TreeDataNode } from "@/react/components/ui/tree";+import { countVisibleRows } from "@/react/components/ui/tree-utils";+import { useCommonSearchScopeOptions } from "@/react/components/useCommonSearchScopeOptions";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import {+ featureToRef,+ pushNotification,+ useCurrentUserV1,+ useDatabaseV1Store,+ useDBGroupStore,+ useEnvironmentV1Store,+ useInstanceV1Store,+ useProjectV1Store,+ useSQLEditorStore,+ useSQLEditorTabStore,+ useSQLEditorTreeStore,+ useSQLEditorUIStore,+} from "@/store";+import { instanceNamePrefix } from "@/store/modules/v1/common";+import type { DatabaseFilter } from "@/store/modules/v1/database";+import type {+ BatchQueryContext,+ QueryDataSourceType,+ SQLEditorTreeNode,+} from "@/types";+import {+ isValidDatabaseGroupName,+ isValidDatabaseName,+ isValidProjectName,+ UNKNOWN_ENVIRONMENT_NAME,+ unknownEnvironment,+} from "@/types";+import { Engine } from "@/types/proto-es/v1/common_pb";+import { DatabaseGroupView } from "@/types/proto-es/v1/database_group_service_pb";+import type { Database } from "@/types/proto-es/v1/database_service_pb";+import { DataSourceType } from "@/types/proto-es/v1/instance_service_pb";+import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";+import {+ extractDatabaseResourceName,+ getConnectionForSQLEditorTab,+ getInstanceResource,+ getValueFromSearchParams,+ getValuesFromSearchParams,+ instanceV1Name,+} from "@/utils";+import { sqlEditorEvents } from "@/views/sql-editor/events";+import { setConnection } from "./actions";+import {+ ConnectionContextMenu,+ type ConnectionContextMenuHandle,+} from "./ConnectionContextMenu";+import { DatabaseGroupTag } from "./DatabaseGroupTag";+import { DatabaseHoverPanel } from "./DatabaseHoverPanel/DatabaseHoverPanel";+import {+ HoverStateProvider,+ useHoverState,+ useProvideHoverState,+} from "./DatabaseHoverPanel/hover-state";+import { Label } from "./TreeNode/Label";+import { useSQLEditorTreeByEnvironment } from "./tree";++type Props = {+ readonly show: boolean;+ /**+ * Bubble paywall triggers up to the parent `ConnectionPanel`. The Vue+ * version owned the `<FeatureModal>` inside the same template as the+ * tree, but in React both Sheet and FeatureModal are Base UI dialogs+ * portaling to the same overlay layer — keeping the FeatureModal as a+ * descendant of the Sheet caused stacking-order bugs (its backdrop+ * could land below the Sheet's popup). The parent now hosts the modal+ * as a sibling of the Sheet, and `ConnectionPaneInner` notifies it via+ * this callback.+ */+ readonly onMissingFeature: (feature: PlanFeature | undefined) => void;+};++type SelectionMode = "DATABASE" | "DATABASE-GROUP";++const getDataSourceTypeLabel = (+ t: (key: string) => string,+ type: DataSourceType+): string =>+ type === DataSourceType.ADMIN+ ? t("sql-editor.batch-query.select-data-source.admin")+ : t("sql-editor.batch-query.select-data-source.readonly");++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/ConnectionPane.vue.+ * Environment-grouped database tree + batch-mode batch-query selection ++ * database-group selection tab. Consumes every Phase 3/4a/4b/4c artifact:+ * - TreeNode/Label (Phase 3)+ * - DatabaseHoverPanel (Phase 3)+ * - DatabaseGroupTag (Phase 4a)+ * - tree.ts hook (Phase 4a)+ * - setConnection, useConnectionMenu, ConnectionContextMenu (Phase 4b)+ * - FeatureModal (Phase 4b)+ * - DatabaseGroupTable (Phase 4c)+ *+ * Uses the shared React `AdvancedSearch` + `useCommonSearchScopeOptions`+ * for `instance` / `label` / `engine` scope chips. Filter fields are+ * derived from `params.scopes` and forwarded to the per-environment+ * `useSQLEditorTreeByEnvironment` hook, matching the Vue behavior.+ */+export function ConnectionPane(props: Props) {+ return <ConnectionPaneWithHoverState {...props} />;+}++function ConnectionPaneWithHoverState(props: Props) {+ const hoverState = useProvideHoverState();+ return (+ <HoverStateProvider value={hoverState}>+ <ConnectionPaneInner {...props} />+ </HoverStateProvider>+ );+}++function ConnectionPaneInner({ show, onMissingFeature }: Props) {+ const { t } = useTranslation();+ const tabStore = useSQLEditorTabStore();+ const editorStore = useSQLEditorStore();+ const uiStore = useSQLEditorUIStore();+ const databaseStore = useDatabaseV1Store();+ const dbGroupStore = useDBGroupStore();+ const environmentStore = useEnvironmentV1Store();+ const projectStore = useProjectV1Store();+ const instanceStore = useInstanceV1Store();+ const treeStore = useSQLEditorTreeStore();+ const currentUser = useCurrentUserV1();++ const supportBatchMode = useVueState(() => tabStore.supportBatchMode);+ const isInBatchMode = useVueState(() => tabStore.isInBatchMode);+ const treeStoreState = useVueState(() => treeStore.state);+ const currentTab = useVueState(() => tabStore.currentTab);+ const currentUserEmail = useVueState(() => currentUser.value.email);+ const projectName = useVueState(() => editorStore.project);+ const projectContextReady = useVueState(+ () => editorStore.projectContextReady+ );+ const environmentList = useVueState(() => environmentStore.environmentList);++ const hasBatchQueryFeature = useVueState(+ () => featureToRef(PlanFeature.FEATURE_BATCH_QUERY).value+ );+ const hasDatabaseGroupFeature = useVueState(+ () => featureToRef(PlanFeature.FEATURE_DATABASE_GROUPS).value+ );++ // Paywall triggers go to the parent (lifted out of this subtree so the+ // FeatureModal portal isn't a descendant of the Sheet's portal).+ const setMissingFeature = onMissingFeature;+ const [switchingConnection, setSwitchingConnection] = useState(false);+ const [selectionMode, setSelectionMode] = useState<SelectionMode>("DATABASE");+ const [searchParams, setSearchParams] = useState<SearchParams>(() =>+ emptySearchParams()+ );+ const queryText = searchParams.query;+ const [showMissingQueryDatabases, setShowMissingQueryDatabases] = useState(+ () => readShowMissingFromStorage(currentUserEmail)+ );++ // The Vue version re-bound to a computed storage key whenever the user+ // email changed (initial hydration from anonymous → real email, or an+ // account switch). Mirror that here: when the email key changes, reload+ // from storage and skip the next write so we don't clobber the new+ // user's saved preference with the previous user's value.+ const loadedForEmailRef = useRef(currentUserEmail);+ useEffect(() => {+ if (loadedForEmailRef.current !== currentUserEmail) {+ loadedForEmailRef.current = currentUserEmail;+ setShowMissingQueryDatabases(+ readShowMissingFromStorage(currentUserEmail)+ );+ return;+ }+ writeShowMissingToStorage(currentUserEmail, showMissingQueryDatabases);+ }, [currentUserEmail, showMissingQueryDatabases]);++ // Local state, seeded `READ_ONLY` on every panel mount. Matches Vue's+ // `state.batchQueryDataSourceType: DataSourceType.READ_ONLY` initial ++ // `watch(..., { immediate: true })` that pushes the value into the tab+ // store on mount — i.e. the tab's saved data-source resets to READ_ONLY+ // each time the drawer opens.+ const [dataSourceType, setDataSourceType] = useState<QueryDataSourceType>(+ DataSourceType.READ_ONLY+ );++ const selectedDatabaseGroupNames = useMemo(+ () => currentTab?.batchQueryContext?.databaseGroups ?? [],+ [currentTab?.batchQueryContext?.databaseGroups]+ );++ // Map<databaseResourceName, groupTitle> for every database covered by+ // any currently-selected database group. Mirrors Vue's+ // `flattenSelectedDatabasesFromGroup` and drives the tree-row checkbox+ // so users can see which databases are already implicitly included via+ // group selection (rendered as checked + disabled + tooltip in batch+ // mode). useVueState — the underlying group cache mutates without the+ // store reference changing, so a deep subscription catches new+ // matchedDatabases as they arrive from the FULL-view fetch.+ const groupCoveredDatabaseTitles = useVueState(+ () => {+ const map = new Map<string, string>();+ for (const groupName of selectedDatabaseGroupNames) {+ const group = dbGroupStore.getDBGroupByName(groupName);+ if (!isValidDatabaseGroupName(group.name)) continue;+ for (const m of group.matchedDatabases) {+ map.set(m.name, group.title);+ }+ }+ return map;+ },+ { deep: true }+ );++ const selectedDatabaseNames = useMemo(() => {+ const databases = currentTab?.batchQueryContext?.databases ?? [];+ if (+ databases.length === 0 &&+ selectedDatabaseGroupNames.length === 0 &&+ currentTab?.connection.database+ ) {+ return [currentTab.connection.database];+ }+ return databases;+ }, [+ currentTab?.batchQueryContext?.databases,+ currentTab?.connection.database,+ selectedDatabaseGroupNames.length,+ ]);++ const projectTitle = useVueState(() => {+ const p = editorStore.project;+ if (!p) return "";+ return projectStore.getProjectByName(p).title;+ });++ const scopeOptions = useCommonSearchScopeOptions([+ "instance",+ "label",+ "engine",+ ]);++ // Derive DatabaseFilter fields from the search scopes, matching the Vue+ // version's slicing of `state.params` into `instance`, `labels`, and+ // `engines`.+ const selectedLabels = useMemo(+ () => getValuesFromSearchParams(searchParams, "label"),+ [searchParams]+ );+ const selectedInstance = useMemo(+ () =>+ getValueFromSearchParams(searchParams, "instance", instanceNamePrefix),+ [searchParams]+ );+ const selectedEngines = useMemo<Engine[]>(+ () =>+ getValuesFromSearchParams(searchParams, "engine")+ .map((name) => Engine[name as keyof typeof Engine])+ .filter((v): v is Engine => typeof v === "number"),+ [searchParams]+ );++ // Per-environment tree hooks are mounted by `EnvironmentTreeSection`;+ // this component only decides which environments to render and holds the+ // "show missing query" toggle.+ const filter = useMemo(+ () => ({+ query: queryText,+ instance: selectedInstance || undefined,+ labels: selectedLabels.length > 0 ? selectedLabels : undefined,+ engines: selectedEngines.length > 0 ? selectedEngines : undefined,+ }),+ [queryText, selectedInstance, selectedLabels, selectedEngines]+ );++ // Vue's `watch(() => props.show, ..., { immediate: true })` only fires+ // when `show` toggles, NOT when batch-mode selections change. Mirror+ // that — depend on `show` alone so toggling a checkbox inside the panel+ // doesn't yank the user back to the DATABASE tab. Read selection+ // lengths through refs so they don't widen the dep array.+ const selectedDatabaseNamesRef = useRef(selectedDatabaseNames);+ selectedDatabaseNamesRef.current = selectedDatabaseNames;+ const selectedDatabaseGroupNamesRef = useRef(selectedDatabaseGroupNames);+ selectedDatabaseGroupNamesRef.current = selectedDatabaseGroupNames;+ useEffect(() => {+ if (!show) return;+ if (selectedDatabaseNamesRef.current.length > 0) {+ setSelectionMode("DATABASE");+ } else if (selectedDatabaseGroupNamesRef.current.length > 0) {+ setSelectionMode("DATABASE-GROUP");+ } else {+ setSelectionMode("DATABASE");+ }+ }, [show]);++ // Keep the `dataSourceType` in the tab store aligned with the UI.+ useEffect(() => {+ tabStore.updateBatchQueryContext({ dataSourceType });+ }, [tabStore, dataSourceType]);++ // Pre-fetch display data for currently-selected databases (so tags render+ // with the right title immediately).+ useEffect(() => {+ if (!currentTab) return;+ void databaseStore.batchGetOrFetchDatabases(selectedDatabaseNames);+ }, [currentTab, databaseStore, selectedDatabaseNames]);++ // Drive treeStore.state transitions so the mask spinner lifts when the+ // project is ready and hides again when the project changes.+ // `tree-ready` is NOT emitted here — at this point each env section is+ // still asynchronously fetching+building its slice of the tree, and the+ // listener uses `treeStore.nodeKeysByTarget` which would return [] for+ // the current connection. Each `EnvironmentTreeSection` emits+ // `tree-ready` when its own buildTree resolves.+ useEffect(() => {+ if (!isValidProjectName(projectName)) return;+ if (!projectContextReady) {+ treeStore.state = "LOADING";+ return;+ }+ treeStore.state = "READY";+ }, [projectName, projectContextReady, treeStore]);++ // Highlight the current tab's connection node in the tree. Mirrors+ // Vue's `getSelectedKeys` + `tree-ready` event listener: when the tree+ // becomes ready, resolve the current connection (database, then+ // instance fallback) and ask `treeStore.nodeKeysByTarget` for the keys+ // that point to that target.+ const [selectedKeys, setSelectedKeys] = useState<string[]>([]);+ useEffect(() => {+ let cancelled = false;+ const compute = async () => {+ const connection = tabStore.currentTab?.connection;+ if (!connection) {+ if (!cancelled) setSelectedKeys([]);+ return;+ }+ if (connection.database) {+ const database = await databaseStore.getOrFetchDatabaseByName(+ connection.database+ );+ if (cancelled) return;+ setSelectedKeys(treeStore.nodeKeysByTarget("database", database));+ return;+ }+ if (connection.instance) {+ const instance = instanceStore.getInstanceByName(connection.instance);+ if (cancelled) return;+ setSelectedKeys(treeStore.nodeKeysByTarget("instance", instance));+ return;+ }+ if (!cancelled) setSelectedKeys([]);+ };+ const unsubscribe = sqlEditorEvents.on("tree-ready", () => {+ void compute();+ });+ // The tree may already be ready by the time we mount (mount-after-emit+ // race). Compute eagerly so we don't miss the initial highlight.+ void compute();+ return () => {+ cancelled = true;+ unsubscribe();+ };+ }, [tabStore, databaseStore, instanceStore, treeStore]);++ // Context-menu imperative handle.+ const contextMenuRef = useRef<ConnectionContextMenuHandle>(null);++ const connect = useCallback(+ (node: SQLEditorTreeNode) => {+ if (node.disabled || node.meta.type !== "database") return;+ const database = (node as SQLEditorTreeNode<"database">).meta+ .target as Database;+ const batchQueryDatabases = [+ ...selectedDatabaseGroupNames,+ database.name,+ ].filter(isValidDatabaseName);+ setConnection({+ database,+ mode: currentTab?.mode,+ newTab: false,+ batchQueryContext: {+ databases: [...new Set(batchQueryDatabases)],+ },+ });+ // Mirror the Vue ConnectionPane: clicking a row commits the+ // connection AND closes the drawer. Without this the drawer stays+ // open and the user can't see the schema panel underneath, so+ // subsequent re-clicks look like nothing happened.+ uiStore.showConnectionPanel = false;+ },+ [selectedDatabaseGroupNames, currentTab?.mode, uiStore]+ );++ const onBatchQueryContextChange = useCallback(+ async (ctx: BatchQueryContext): Promise<boolean> => {+ setSwitchingConnection(true);+ try {+ const queryable = await getQueryableDatabase(+ ctx,+ databaseStore,+ dbGroupStore+ );+ const currentConnection = getConnectionForSQLEditorTab(+ tabStore.currentTab+ );+ if (+ !currentConnection.database?.name ||+ currentConnection.database?.name !== queryable?.name+ ) {+ setConnection({+ database: queryable,+ mode: "WORKSHEET",+ newTab: false,+ batchQueryContext: ctx,+ });+ } else {+ tabStore.updateBatchQueryContext(ctx);+ }+ return !!queryable;+ } finally {+ setSwitchingConnection(false);+ }+ },+ [tabStore, databaseStore, dbGroupStore]+ );++ const handleToggleDatabase = useCallback(+ async (database: string, check: boolean) => {+ let dbs: string[] = [...selectedDatabaseNames];+ if (check) {+ if (!dbs.includes(database)) dbs.push(database);+ if (dbs.length > 1 && !hasBatchQueryFeature) {+ setMissingFeature(PlanFeature.FEATURE_BATCH_QUERY);+ return;+ }+ } else {+ dbs = dbs.filter((d) => d !== database);+ }+ const ctx: BatchQueryContext = cloneDeep({+ ...currentTab?.batchQueryContext,+ databases: dbs,+ });+ await onBatchQueryContextChange(ctx);+ },+ [+ selectedDatabaseNames,+ hasBatchQueryFeature,+ currentTab?.batchQueryContext,+ onBatchQueryContextChange,+ ]+ );++ const handleSelectDatabaseGroup = useCallback(+ async (name: string) => {+ const ctx: BatchQueryContext = cloneDeep({+ ...(currentTab?.batchQueryContext ?? { databases: [] }),+ databaseGroups: [name],+ });+ const ok = await onBatchQueryContextChange(ctx);+ if (ok) {+ uiStore.showConnectionPanel = false;+ } else {+ pushNotification({+ module: "bytebase",+ style: "CRITICAL",+ title: t("sql-editor.no-queriable-database"),+ });+ }+ },+ [currentTab?.batchQueryContext, onBatchQueryContextChange, uiStore, t]+ );++ const handleSelectedGroupsChange = useCallback(+ async (next: string[]) => {+ if (next.length > 0) {+ if (!hasBatchQueryFeature) {+ setMissingFeature(PlanFeature.FEATURE_BATCH_QUERY);+ return;+ }+ if (!hasDatabaseGroupFeature) {+ setMissingFeature(PlanFeature.FEATURE_DATABASE_GROUPS);+ return;+ }+ }+ const ctx: BatchQueryContext = cloneDeep({+ ...(currentTab?.batchQueryContext ?? { databases: [] }),+ databaseGroups: next,+ });+ const ok = await onBatchQueryContextChange(ctx);+ if (next.length > 0 && !ok) {+ pushNotification({+ module: "bytebase",+ style: "CRITICAL",+ title: t("sql-editor.no-queriable-database"),+ });+ }+ },+ [+ hasBatchQueryFeature,+ hasDatabaseGroupFeature,+ currentTab?.batchQueryContext,+ onBatchQueryContextChange,+ t,+ ]+ );++ // Vue routes uncheck through `onDatabaseGroupSelectionUpdate`, which+ // performs the feature gate + notification. Mirror that here so feature+ // checks fire on remove too.+ const handleUncheckDatabaseGroup = useCallback(+ async (groupName: string) => {+ const next = selectedDatabaseGroupNames.filter((n) => n !== groupName);+ await handleSelectedGroupsChange(next);+ },+ [selectedDatabaseGroupNames, handleSelectedGroupsChange]+ );++ return (+ <div className="sql-editor-tree h-full relative">+ {supportBatchMode && (+ <BatchModeHeader+ projectTitle={projectTitle}+ selectedDatabaseCount={selectedDatabaseNames.length}+ selectedDatabaseNames={selectedDatabaseNames}+ selectedDatabaseGroupNames={selectedDatabaseGroupNames}+ switchingConnection={switchingConnection}+ hasDatabaseGroupFeature={hasDatabaseGroupFeature}+ isInBatchMode={isInBatchMode}+ dataSourceType={dataSourceType}+ onDataSourceTypeChange={setDataSourceType}+ onToggleDatabase={handleToggleDatabase}+ onUncheckDatabaseGroup={handleUncheckDatabaseGroup}+ />+ )}++ {currentTab && <Separator className="my-3" />}++ <Tabs+ value={selectionMode}+ onValueChange={(v) => setSelectionMode(v as SelectionMode)}+ className="px-4"+ >+ <TabsList>+ <TabsTrigger value="DATABASE">{t("common.databases")}</TabsTrigger>+ <TabsTrigger+ value="DATABASE-GROUP"+ disabled={!hasBatchQueryFeature || !hasDatabaseGroupFeature}+ >+ <Tooltip+ content={+ hasBatchQueryFeature && hasDatabaseGroupFeature+ ? ""+ : t("subscription.contact-to-upgrade")+ }+ >+ {t("common.database-group")}+ </Tooltip>+ </TabsTrigger>+ </TabsList>++ <TabsPanel value="DATABASE">+ <div className="flex flex-col gap-y-1">+ <AdvancedSearch+ params={searchParams}+ scopeOptions={scopeOptions}+ placeholder={t("database.filter-database")}+ onParamsChange={setSearchParams}+ />+ {treeStoreState === "READY" && (+ <div className="flex flex-col gap-y-2 text-sm select-none pt-1">+ <label className="inline-flex items-center gap-x-2">+ <input+ type="checkbox"+ className="rounded-xs border-control-border"+ checked={showMissingQueryDatabases}+ onChange={(e) =>+ setShowMissingQueryDatabases(e.target.checked)+ }+ />+ {t("sql-editor.show-databases-without-query-permission")}+ </label>++ {[...environmentList, unknownEnvironment()].map((env) => (+ <EnvironmentTreeSection+ key={env.name}+ environmentName={env.name}+ email={currentUserEmail}+ filter={filter}+ showMissingQueryDatabases={showMissingQueryDatabases}+ projectContextReady={projectContextReady}+ query={queryText}+ isUnknownEnvironment={env.name === UNKNOWN_ENVIRONMENT_NAME}+ selectedDatabaseNames={selectedDatabaseNames}+ groupCoveredDatabaseTitles={groupCoveredDatabaseTitles}+ selectedKeys={selectedKeys}+ switchingConnection={switchingConnection}+ onConnect={connect}+ onToggleDatabase={handleToggleDatabase}+ onContextMenu={(node, e) =>+ contextMenuRef.current?.show(node, e)+ }+ />+ ))}+ </div>+ )}+ </div>+ </TabsPanel>++ <TabsPanel value="DATABASE-GROUP">+ <DatabaseGroupTable+ projectName={projectName}+ view={DatabaseGroupView.FULL}+ leadingLabel={t("database-group.select")}+ showSelection+ showExternalLink+ selectedDatabaseGroupNames={selectedDatabaseGroupNames}+ onSelectedDatabaseGroupNamesChange={handleSelectedGroupsChange}+ onRowClick={(_, group) => handleSelectDatabaseGroup(group.name)}+ />+ </TabsPanel>+ </Tabs>++ <ConnectionContextMenu ref={contextMenuRef} />++ <DatabaseHoverPanel offsetX={10} offsetY={4} margin={4} />++ {treeStoreState !== "READY" && (+ <div className="absolute inset-0 bg-white/75 flex items-center justify-center">+ <span className="text-control text-sm">+ {t("sql-editor.loading-databases")}+ </span>+ </div>+ )}+ </div>+ );+}++// ---- Batch-mode header --------------------------------------------------++function BatchModeHeader({+ projectTitle,+ selectedDatabaseCount,+ selectedDatabaseNames,+ selectedDatabaseGroupNames,+ switchingConnection,+ hasDatabaseGroupFeature,+ isInBatchMode,+ dataSourceType,+ onDataSourceTypeChange,+ onToggleDatabase,+ onUncheckDatabaseGroup,+}: {+ projectTitle: string;+ selectedDatabaseCount: number;+ selectedDatabaseNames: string[];+ selectedDatabaseGroupNames: string[];+ switchingConnection: boolean;+ hasDatabaseGroupFeature: boolean;+ isInBatchMode: boolean;+ dataSourceType: QueryDataSourceType;+ onDataSourceTypeChange: (v: QueryDataSourceType) => void;+ onToggleDatabase: (name: string, check: boolean) => void;+ onUncheckDatabaseGroup: (name: string) => void;+}) {+ const { t } = useTranslation();+ const databaseStore = useDatabaseV1Store();++ return (+ <div className="w-full px-4 mt-4">+ <div className="text-control-light text-sm mb-2 w-full leading-4 flex flex-col items-start gap-x-1">+ <div className="flex items-center gap-x-1">+ <FeatureBadge feature={PlanFeature.FEATURE_BATCH_QUERY} />+ {t("sql-editor.batch-query.description", {+ database: selectedDatabaseCount,+ group: selectedDatabaseGroupNames.length,+ project: projectTitle,+ })}+ </div>+ </div>++ <div className="w-full mt-1 flex flex-row justify-start items-start flex-wrap gap-2">+ {selectedDatabaseNames.map((db) => (+ <SelectedDatabaseTag+ key={db}+ name={db}+ disabled={switchingConnection}+ onClose={() => onToggleDatabase(db, false)}+ resolveDatabase={() => databaseStore.getDatabaseByName(db)}+ />+ ))}+ {hasDatabaseGroupFeature &&+ selectedDatabaseGroupNames.map((name) => (+ <DatabaseGroupTag+ key={name}+ databaseGroupName={name}+ disabled={switchingConnection}+ onUncheck={onUncheckDatabaseGroup}+ />+ ))}+ {isInBatchMode && <Separator className="my-2 w-full" />}+ {isInBatchMode && (+ <div className="w-full">+ <div className="text-control-light text-sm flex items-center gap-x-1">+ {t("sql-editor.batch-query.select-data-source.self")}+ <Tooltip+ content={t("sql-editor.batch-query.select-data-source.tooltip")}+ >+ <Info className="size-4" />+ </Tooltip>+ </div>+ <RadioGroup+ value={String(dataSourceType)}+ onValueChange={(v) =>+ onDataSourceTypeChange(Number(v) as QueryDataSourceType)+ }+ >+ <RadioGroupItem value={String(DataSourceType.ADMIN)}>+ {getDataSourceTypeLabel(t, DataSourceType.ADMIN)}+ </RadioGroupItem>+ <RadioGroupItem value={String(DataSourceType.READ_ONLY)}>+ {getDataSourceTypeLabel(t, DataSourceType.READ_ONLY)}+ </RadioGroupItem>+ </RadioGroup>+ </div>+ )}+ </div>+ </div>+ );+}++function SelectedDatabaseTag({+ name,+ disabled,+ onClose,+ resolveDatabase,+}: {+ name: string;+ disabled: boolean;+ onClose: () => void;+ resolveDatabase: () => ReturnType<+ ReturnType<typeof useDatabaseV1Store>["getDatabaseByName"]+ >;+}) {+ const { t } = useTranslation();+ const database = useVueState(resolveDatabase);+ const instance = useMemo(() => {+ if (!database) return null;+ return getInstanceResource(database);+ }, [database]);+ const dbLabel = database+ ? extractDatabaseResourceName(database.name).databaseName+ : extractDatabaseResourceName(name).databaseName;+ const iconPath = instance ? EngineIconPath[instance.engine] : undefined;++ return (+ <span+ className={cn(+ "inline-flex items-center gap-x-1 rounded-sm border border-control-border bg-control-bg/60 pl-2 pr-1 py-0.5 text-sm",+ disabled && "opacity-50"+ )}+ >+ {iconPath && <img src={iconPath} alt="" className="size-4 shrink-0" />}+ {instance && (+ <span className="truncate max-w-[8rem]">+ {instanceV1Name(instance)}+ </span>+ )}+ <ChevronRight className="size-3 shrink-0" />+ <span className="truncate max-w-[10rem]">{dbLabel}</span>+ <button+ type="button"+ className={cn(+ "inline-flex items-center justify-center size-4 rounded-sm",+ "hover:bg-control-bg-hover disabled:opacity-50 disabled:cursor-not-allowed"+ )}+ aria-label={t("common.close")}+ disabled={disabled}+ onClick={(e) => {+ e.stopPropagation();+ if (!disabled) onClose();+ }}+ >+ <X className="size-3" />+ </button>+ </span>+ );+}++// ---- Per-environment sub-tree ------------------------------------------++function EnvironmentTreeSection(props: {+ environmentName: string;+ email: string;+ filter: DatabaseFilter;+ showMissingQueryDatabases: boolean;+ projectContextReady: boolean;+ query: string;+ isUnknownEnvironment: boolean;+ selectedDatabaseNames: string[];+ /** databaseResourceName → groupTitle for every database implicitly+ * selected via a chosen database group. The row checkbox unions this+ * with `selectedDatabaseNames` and uses the title for the disabled-+ * checkbox tooltip. */+ groupCoveredDatabaseTitles: Map<string, string>;+ /** Tree-row keys to highlight as the current connection (1:1 with Vue+ * `selectedKeys` from `getSelectedKeys()`). */+ selectedKeys: string[];+ switchingConnection: boolean;+ onConnect: (node: SQLEditorTreeNode) => void;+ onToggleDatabase: (name: string, check: boolean) => void;+ onContextMenu: (node: SQLEditorTreeNode, e: React.MouseEvent) => void;+}) {+ const {+ environmentName,+ email,+ filter,+ showMissingQueryDatabases,+ projectContextReady,+ query,+ isUnknownEnvironment,+ selectedDatabaseNames,+ groupCoveredDatabaseTitles,+ selectedKeys,+ switchingConnection,+ onConnect,+ onToggleDatabase,+ onContextMenu,+ } = props;++ const treeByEnv = useSQLEditorTreeByEnvironment(environmentName, { email });++ // Read the latest show-missing flag from inside the async `.then()`+ // below. The fetch can outlive the render that started it, so capturing+ // `showMissingQueryDatabases` directly would let an in-flight rebuild+ // overwrite the tree with a stale flag (e.g. user toggles the checkbox+ // mid-fetch — the toggle's own buildTree runs first, then the older+ // .then() lands and clobbers it).+ const showMissingRef = useRef(showMissingQueryDatabases);+ showMissingRef.current = showMissingQueryDatabases;++ // Kick off fetch when filter / project-readiness changes. The parent+ // memoizes `filter` on (queryText, instance, labels, engines), so a+ // single dep on `filter` covers scope-chip changes too — depending only+ // on `filter.query` (as before) left scope edits stale until the user+ // also retyped the search.+ // treeByEnv identity is stable per-render via the hook's internals.+ // After buildTree resolves we emit `tree-ready` so the parent's+ // current-connection-highlight effect can recompute against the now-+ // populated `treeStore.nodeKeysByTarget`. Emitting here (per-env, after+ // populate) instead of in the project-readiness effect avoids a race+ // where the highlight is computed against an empty tree.+ useEffect(() => {+ if (!projectContextReady) return;+ void treeByEnv.prepareDatabases(filter).then(() => {+ treeByEnv.buildTree(showMissingRef.current);+ void sqlEditorEvents.emit("tree-ready");+ });+ }, [projectContextReady, filter]);++ // Rebuild when the "show missing" toggle flips.+ useEffect(() => {+ treeByEnv.buildTree(showMissingQueryDatabases);+ }, [showMissingQueryDatabases]);++ // First-time default-expand. The Vue version did this by listening to the+ // `tree-ready` event and seeding `expandedKeys` from the global tree+ // store; in React each environment owns its own expand state, so we+ // expand from the per-env tree directly. After the user toggles anything+ // (`expandedState.initialized = true`), we leave their preference alone.+ useEffect(() => {+ if (treeByEnv.expandedState.initialized) return;+ if (treeByEnv.tree.length === 0) return;+ treeByEnv.setExpandedKeys(collectAllNodeKeys(treeByEnv.tree));+ }, [treeByEnv.tree, treeByEnv.expandedState.initialized]);++ const selectedSet = useMemo(+ () => new Set(selectedDatabaseNames),+ [selectedDatabaseNames]+ );++ // Hide the env section entirely when it's the "unknown" bucket with no+ // children (matches Vue's `v-if="env !== UNKNOWN || !treeIsEmpty"` guard).+ if (isUnknownEnvironment && treeIsEmpty(treeByEnv.tree)) {+ return null;+ }++ const data = treeByEnv.tree.map(toTreeDataNode);++ const expandedKeySet = useMemo(+ () => new Set(treeByEnv.expandedState.expandedKeys),+ [treeByEnv.expandedState.expandedKeys]+ );+ // Mirror SheetTree's pattern: the Tree primitive has no internal scroll,+ // so its `height` must equal the count of visible rows × row height. The+ // parent decides whether to clip / scroll. This lets each environment+ // subtree expand naturally instead of being capped at a single row.+ // Filter is server-side via `params.scopes` + `filter.query` so we pass+ // an empty keyword + a no-op `searchMatch` predicate.+ const visibleRowCount = useMemo(+ () =>+ treeByEnv.tree.reduce(+ (total, root) =>+ total + countVisibleRows(root, expandedKeySet, "", () => false),+ 0+ ),+ [treeByEnv.tree, expandedKeySet]+ );++ return (+ <div className="flex flex-col gap-y-1 pt-2 pb-2">+ <Tree<SQLEditorTreeNode>+ data={data}+ selectedIds={selectedKeys}+ expandedIds={treeByEnv.expandedState.expandedKeys}+ onToggle={(id) => {+ const next = new Set(treeByEnv.expandedState.expandedKeys);+ if (next.has(id)) next.delete(id);+ else next.add(id);+ treeByEnv.setExpandedKeys([...next]);+ }}+ height={Math.max(visibleRowCount, 1) * ROW_HEIGHT}+ rowHeight={ROW_HEIGHT}+ renderNode={({ node, style }) => {+ const data = node.data.data;+ const isDatabase = data.meta.type === "database";+ const databaseName = isDatabase+ ? (data.meta.target as { name: string }).name+ : "";+ const matchedGroupTitle =+ isDatabase && groupCoveredDatabaseTitles.has(databaseName)+ ? groupCoveredDatabaseTitles.get(databaseName)+ : undefined;+ const checked =+ isDatabase &&+ (selectedSet.has(databaseName) || matchedGroupTitle !== undefined);+ return (+ <TreeRow+ style={style}+ node={data}+ depth={node.level}+ isOpen={!!node.isOpen}+ hasChildren={!!data.children && data.children.length > 0}+ query={query}+ selected={checked}+ checkDisabled={+ switchingConnection || matchedGroupTitle !== undefined+ }+ checkTooltip={+ matchedGroupTitle !== undefined ? matchedGroupTitle : undefined+ }+ onClick={(e) => {+ e.stopPropagation();+ if (isDatabase) {+ onConnect(data);+ } else {+ node.toggle();+ }+ }}+ onToggleChecked={(next) => {+ if (isDatabase) {+ onToggleDatabase(databaseName, next);+ }+ }}+ onContextMenu={(e) => onContextMenu(data, e)}+ />+ );+ }}+ />+ {treeByEnv.fetchDataState.nextPageToken &&+ treeByEnv.expandedState.expandedKeys.includes(environmentName) &&+ (!treeIsEmpty(treeByEnv.tree) || showMissingQueryDatabases) && (+ <LoadMoreButton+ loading={treeByEnv.fetchDataState.loading}+ onLoadMore={() =>+ treeByEnv.fetchDatabases(filter).then(() => {+ treeByEnv.buildTree(showMissingQueryDatabases);+ })+ }+ />+ )}+ </div>+ );+}++function TreeRow({+ style,+ node,+ isOpen,+ hasChildren,+ query,+ selected,+ checkDisabled,+ checkTooltip,+ onClick,+ onToggleChecked,+ onContextMenu,+}: {+ style: React.CSSProperties;+ node: SQLEditorTreeNode;+ /** Whether this row is currently expanded (for non-leaf nodes). */+ isOpen: boolean;+ /** Whether the node has children (controls chevron visibility). */+ hasChildren: boolean;+ depth: number;+ query: string;+ /** Whether the row is "checked" (batch-query selection or implicit+ * via group). Doubles as the row tint condition. */+ selected: boolean;+ /** True when the checkbox should be locked, e.g. mid-connection-switch+ * or when membership is forced by a selected group. */+ checkDisabled: boolean;+ /** Tooltip shown on the disabled checkbox — typically the group title+ * that pulls this database into the batch query implicitly. */+ checkTooltip?: string;+ onClick: (e: React.MouseEvent) => void;+ onToggleChecked: (checked: boolean) => void;+ onContextMenu: (e: React.MouseEvent) => void;+}) {+ const hoverState = useHoverState();+ const rowRef = useRef<HTMLDivElement | null>(null);++ const handleMouseEnter = (e: React.MouseEvent) => {+ if (node.meta.type !== "database") return;+ const el = e.currentTarget as HTMLElement;+ const rect = el.getBoundingClientRect();+ hoverState.setPosition({ x: rect.left, y: rect.bottom });+ // Re-use the `0` override when we're already showing something — the+ // panel stays without blinking when sliding between rows.+ if (hoverState.state) {+ hoverState.update({ node }, "before", 0);+ } else {+ hoverState.update({ node }, "before");+ }+ };++ const handleMouseLeave = () => {+ hoverState.update(undefined, "after");+ };++ return (+ <div+ ref={rowRef}+ style={style}+ className={cn(+ "bb-conn-pane-row flex items-center gap-x-1 w-full pr-2 cursor-pointer rounded-sm",+ "hover:bg-control-bg/70",+ selected && "bg-accent/10"+ )}+ data-node-key={node.key}+ onClick={onClick}+ onMouseEnter={handleMouseEnter}+ onMouseLeave={handleMouseLeave}+ onContextMenu={(e) => {+ e.preventDefault();+ onContextMenu(e);+ }}+ >+ {/* Expand / collapse chevron — shown for non-leaf rows. Renders an+ empty spacer for leaf rows so labels stay vertically aligned. */}+ <span className="shrink-0 inline-flex size-4 items-center justify-center text-control-light">+ {hasChildren ? (+ isOpen ? (+ <ChevronDown className="size-3.5" />+ ) : (+ <ChevronRight className="size-3.5" />+ )+ ) : null}+ </span>+ <Label+ node={node}+ keyword={query}+ checked={selected}+ checkDisabled={checkDisabled}+ checkTooltip={checkTooltip}+ onCheckedChange={onToggleChecked}+ />+ </div>+ );+}++function LoadMoreButton({+ loading,+ onLoadMore,+}: {+ loading: boolean;+ onLoadMore: () => Promise<void>;+}) {+ const { t } = useTranslation();+ return (+ <div className="w-full flex items-center justify-start pl-4">+ <button+ type="button"+ className="text-sm text-accent hover:underline disabled:opacity-50"+ disabled={loading}+ onClick={() => void onLoadMore()}+ >+ {t("common.load-more")}+ </button>+ </div>+ );+}++// ---- utilities ---------------------------------------------------------++const ROW_HEIGHT = 24;++function toTreeDataNode(+ node: SQLEditorTreeNode+): TreeDataNode<SQLEditorTreeNode> {+ return {+ id: node.key,+ data: node,+ children: node.children?.map(toTreeDataNode),+ };+}++function treeIsEmpty(nodes: SQLEditorTreeNode[]): boolean {+ if (nodes.length === 0) return true;+ const [root] = nodes;+ const children = root.children;+ return !children || children.length === 0;+}++/**+ * Walks the tree and returns every node key. Used to seed `expandedKeys`+ * the first time an environment subtree is rendered so the user sees a+ * fully-expanded list by default — matching the Vue ConnectionPane.+ */+function collectAllNodeKeys(nodes: SQLEditorTreeNode[]): string[] {+ const out: string[] = [];+ const visit = (node: SQLEditorTreeNode) => {+ out.push(node.key);+ for (const child of node.children ?? []) visit(child);+ };+ for (const root of nodes) visit(root);+ return out;+}++/**+ * 1:1 port of `getQueryableDatabase` from the Vue ConnectionPane. Despite+ * the name, the original returns the *first* database in the group — it+ * does not filter for `isDatabaseV1Queryable`. The downstream+ * `setConnection` call attempts the connection regardless; the+ * "no-queriable-database" notification is only surfaced when the function+ * returns `undefined` (i.e. no databases at all in any picked group).+ */+async function getQueryableDatabase(+ ctx: BatchQueryContext,+ databaseStore: ReturnType<typeof useDatabaseV1Store>,+ dbGroupStore: ReturnType<typeof useDBGroupStore>+) {+ if (ctx.databases.length > 0) {+ return databaseStore.getDatabaseByName(ctx.databases[0]);+ }+ for (const groupName of ctx.databaseGroups ?? []) {+ const group = dbGroupStore.getDBGroupByName(groupName);+ if (!isValidDatabaseGroupName(group.name)) continue;+ const databases = await databaseStore.batchGetOrFetchDatabases(+ group.matchedDatabases.map((d) => d.name)+ );+ if (databases.length > 0) return databases[0];+ }+ return undefined;+}++function storageKey(email: string) {+ return `bb.sql-editor.show-missing-query-db.${email || "anonymous"}`;+}++function readShowMissingFromStorage(email: string): boolean {+ try {+ const raw = localStorage.getItem(storageKey(email));+ if (raw === null) return true;+ return JSON.parse(raw) as boolean;+ } catch {+ return true;+ }+}++function writeShowMissingToStorage(email: string, value: boolean) {+ try {+ localStorage.setItem(storageKey(email), JSON.stringify(value));+ } catch {+ /* ignore */+ }+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseGroupTag.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseGroupTag.test.tsxnew file mode 100644index 0000000000..6181295660--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseGroupTag.test.tsx@@ -0,0 +1,147 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const mocks = vi.hoisted(() => ({+ getOrFetchDBGroupByName: vi.fn().mockResolvedValue(undefined),+ getDBGroupByName: vi.fn(),+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+}));++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("@/store", () => ({+ useDBGroupStore: () => ({+ getOrFetchDBGroupByName: mocks.getOrFetchDBGroupByName,+ getDBGroupByName: mocks.getDBGroupByName,+ }),+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/types/proto-es/v1/database_group_service_pb", () => ({+ DatabaseGroupView: { FULL: 2 },+}));++vi.mock("@/react/components/ui/tooltip", () => ({+ Tooltip: ({ children }: { children: React.ReactNode }) => <>{children}</>,+}));++let DatabaseGroupTag: typeof import("./DatabaseGroupTag").DatabaseGroupTag;++const renderIntoContainer = (element: 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 () => {+ vi.clearAllMocks();+ mocks.useVueState.mockImplementation((getter) => getter());+ ({ DatabaseGroupTag } = await import("./DatabaseGroupTag"));+});++describe("DatabaseGroupTag", () => {+ test("renders nothing while the group is not yet resolved", () => {+ mocks.getDBGroupByName.mockReturnValue({ name: "", title: "" });+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupTag+ databaseGroupName="projects/p/databaseGroups/g"+ onUncheck={vi.fn()}+ />+ );+ render();+ expect(container.textContent).toBe("");+ unmount();+ });++ test("renders group title + close button once resolved", () => {+ mocks.getDBGroupByName.mockReturnValue({+ name: "projects/p/databaseGroups/g",+ title: "My Group",+ });+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupTag+ databaseGroupName="projects/p/databaseGroups/g"+ onUncheck={vi.fn()}+ />+ );+ render();+ expect(container.textContent).toContain("My Group");+ expect(+ container.querySelector("button[aria-label='common.close']")+ ).not.toBeNull();+ unmount();+ });++ test("close button fires onUncheck with the group name", () => {+ mocks.getDBGroupByName.mockReturnValue({+ name: "projects/p/databaseGroups/g",+ title: "G",+ });+ const onUncheck = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupTag+ databaseGroupName="projects/p/databaseGroups/g"+ onUncheck={onUncheck}+ />+ );+ render();+ const btn = container.querySelector(+ "button[aria-label='common.close']"+ ) as HTMLButtonElement;+ act(() => {+ btn.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(onUncheck).toHaveBeenCalledWith("projects/p/databaseGroups/g");+ unmount();+ });++ test("close button is disabled when disabled prop is set", () => {+ mocks.getDBGroupByName.mockReturnValue({+ name: "projects/p/databaseGroups/g",+ title: "G",+ });+ const onUncheck = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseGroupTag+ databaseGroupName="projects/p/databaseGroups/g"+ disabled+ onUncheck={onUncheck}+ />+ );+ render();+ const btn = container.querySelector(+ "button[aria-label='common.close']"+ ) as HTMLButtonElement;+ expect(btn.disabled).toBe(true);+ act(() => {+ btn.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(onUncheck).not.toHaveBeenCalled();+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseGroupTag.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseGroupTag.tsxnew file mode 100644index 0000000000..5a6780ea67--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseGroupTag.tsx@@ -0,0 +1,70 @@+import { Boxes, X } from "lucide-react";+import { useEffect } from "react";+import { useTranslation } from "react-i18next";+import { Tooltip } from "@/react/components/ui/tooltip";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import { useDBGroupStore } from "@/store";+import { DatabaseGroupView } from "@/types/proto-es/v1/database_group_service_pb";++type Props = {+ readonly databaseGroupName: string;+ readonly disabled?: boolean;+ readonly onUncheck: (databaseGroupName: string) => void;+};++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseGroupTag.vue.+ * Closable tag representing a selected database group. Fetches the group+ * lazily on mount and hides itself until resolved.+ */+export function DatabaseGroupTag({+ databaseGroupName,+ disabled,+ onUncheck,+}: Props) {+ const { t } = useTranslation();+ const store = useDBGroupStore();++ useEffect(() => {+ void store.getOrFetchDBGroupByName(databaseGroupName, {+ view: DatabaseGroupView.FULL,+ });+ }, [store, databaseGroupName]);++ const databaseGroup = useVueState(() =>+ store.getDBGroupByName(databaseGroupName)+ );++ if (!databaseGroup || !databaseGroup.name) return null;++ return (+ <Tooltip content={t("common.database-group")}>+ <span+ className={cn(+ "inline-flex items-center gap-x-1 rounded-sm border border-control-border bg-control-bg/60 pl-2 pr-1 py-0.5 text-sm",+ disabled && "opacity-50"+ )}+ >+ <Boxes className="size-4 shrink-0" />+ <span className="truncate max-w-[12rem]">{databaseGroup.title}</span>+ <button+ type="button"+ className={cn(+ "inline-flex items-center justify-center size-4 rounded-sm",+ "hover:bg-control-bg-hover disabled:opacity-50 disabled:cursor-not-allowed"+ )}+ aria-label={t("common.close")}+ disabled={disabled}+ onClick={(e) => {+ e.stopPropagation();+ if (disabled) return;+ onUncheck(databaseGroupName);+ }}+ >+ <X className="size-3" />+ </button>+ </span>+ </Tooltip>+ );+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.test.tsxnew file mode 100644index 0000000000..c80cbcdb39--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.test.tsx@@ -0,0 +1,161 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTreeNode } from "@/types";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++globalThis.ResizeObserver = class ResizeObserver {+ observe() {}+ unobserve() {}+ disconnect() {}+};++const mocks = vi.hoisted(() => ({+ useHoverState: vi.fn(),+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+}));++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("./hover-state", () => ({+ useHoverState: mocks.useHoverState,+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/store", () => ({+ useSQLEditorStore: () => ({ project: "" }),+}));++vi.mock("@/utils", () => ({+ getDatabaseProject: () => ({ name: "projects/p", title: "P" }),+ getInstanceResource: () => ({+ name: "instances/prod",+ title: "Prod",+ engine: "MYSQL",+ }),+ instanceV1Name: (inst: { title: string }) => inst.title,+ minmax: (v: number, lo: number, hi: number) => Math.max(lo, Math.min(hi, v)),+ projectV1Name: (p: { title: string }) => p.title,+}));++vi.mock("@/react/components/EnvironmentLabel", () => ({+ EnvironmentLabel: ({ environmentName }: { environmentName: string }) => (+ <span data-testid="env-label">{environmentName}</span>+ ),+}));++vi.mock("@/react/components/ui/layer", () => ({+ getLayerRoot: () => document.body,+ LAYER_SURFACE_CLASS: "",+}));++let DatabaseHoverPanel: typeof import("./DatabaseHoverPanel").DatabaseHoverPanel;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeDatabaseNode = (): SQLEditorTreeNode =>+ ({+ key: "databases/bb",+ meta: {+ type: "database",+ target: {+ name: "instances/prod/databases/bb",+ effectiveEnvironment: "environments/dev",+ project: "projects/p",+ labels: { env: "prod", tier: "" },+ },+ },+ }) as unknown as SQLEditorTreeNode;++beforeEach(async () => {+ vi.clearAllMocks();+ mocks.useVueState.mockImplementation((getter) => getter());+ ({ DatabaseHoverPanel } = await import("./DatabaseHoverPanel"));+});++describe("DatabaseHoverPanel", () => {+ test("renders nothing when state is undefined", () => {+ mocks.useHoverState.mockReturnValue({+ state: undefined,+ position: { x: 0, y: 0 },+ update: vi.fn(),+ setPosition: vi.fn(),+ });+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseHoverPanel offsetX={0} offsetY={0} margin={0} />+ );+ render();+ expect(container.querySelector("[data-testid='env-label']")).toBeNull();+ unmount();+ });++ test("renders database context when state + non-zero position provided", () => {+ mocks.useHoverState.mockReturnValue({+ state: { node: makeDatabaseNode() },+ position: { x: 100, y: 200 },+ update: vi.fn(),+ setPosition: vi.fn(),+ });+ const { render, unmount } = renderIntoContainer(+ <DatabaseHoverPanel offsetX={10} offsetY={20} margin={0} />+ );+ render();+ const panel = document.body.querySelector(+ "[data-testid='env-label']"+ ) as HTMLElement | null;+ expect(panel).not.toBeNull();+ expect(panel?.textContent).toBe("environments/dev");+ // Labels block: "env" key with value "prod", "tier" key with empty value+ expect(document.body.textContent).toContain("env");+ expect(document.body.textContent).toContain("prod");+ expect(document.body.textContent).toContain("tier");+ unmount();+ });++ test("clamps y to window height minus margin", () => {+ mocks.useHoverState.mockReturnValue({+ state: { node: makeDatabaseNode() },+ position: { x: 0, y: 99999 },+ update: vi.fn(),+ setPosition: vi.fn(),+ });+ const { render, unmount } = renderIntoContainer(+ <DatabaseHoverPanel offsetX={0} offsetY={0} margin={10} />+ );+ render();+ const fixed = document.body.querySelector(+ "div.fixed"+ ) as HTMLDivElement | null;+ expect(fixed).not.toBeNull();+ const top = parseFloat(fixed!.style.top);+ expect(top).toBeLessThanOrEqual(window.innerHeight);+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.tsxnew file mode 100644index 0000000000..8f69092e10--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.tsx@@ -0,0 +1,170 @@+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";+import { createPortal } from "react-dom";+import { useTranslation } from "react-i18next";+import { EnvironmentLabel } from "@/react/components/EnvironmentLabel";+import { getLayerRoot, LAYER_SURFACE_CLASS } from "@/react/components/ui/layer";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import { useSQLEditorStore } from "@/store";+import type { Position, SQLEditorTreeNode } from "@/types";+import {+ getDatabaseProject,+ getInstanceResource,+ instanceV1Name,+ minmax,+ projectV1Name,+} from "@/utils";+import { useHoverState } from "./hover-state";++type Props = {+ readonly offsetX: number;+ readonly offsetY: number;+ readonly margin: number;+ readonly onClickOutside?: (e: MouseEvent) => void;+};++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.vue.+ * Floating panel anchored at the hovered tree row showing database context+ * (environment, instance, project, labels). Clamps the y coordinate so the+ * panel stays fully within the viewport.+ */+export function DatabaseHoverPanel({+ offsetX,+ offsetY,+ margin,+ onClickOutside,+}: Props) {+ const { t } = useTranslation();+ const editorStore = useSQLEditorStore();+ const { state, position, update } = useHoverState();++ const hasProjectContext = useVueState(() => !!editorStore.project);++ const popoverRef = useRef<HTMLDivElement | null>(null);+ const [popoverHeight, setPopoverHeight] = useState(0);++ useLayoutEffect(() => {+ const el = popoverRef.current;+ if (!el) return;+ setPopoverHeight(el.getBoundingClientRect().height);+ const ro = new ResizeObserver(() => {+ setPopoverHeight(el.getBoundingClientRect().height);+ });+ ro.observe(el);+ return () => ro.disconnect();+ }, [state]);++ const database = useMemo(() => {+ if (!state?.node) return undefined;+ const { type, target } = state.node.meta;+ if (type !== "database") return undefined;+ return target as SQLEditorTreeNode<"database">["meta"]["target"];+ }, [state]);++ const show = state !== undefined && position.x !== 0 && position.y !== 0;++ const displayPosition = useMemo<Position>(() => {+ const p: Position = {+ x: position.x + offsetX,+ y: position.y + offsetY,+ };+ if (typeof window !== "undefined") {+ const yMin = margin;+ const yMax = window.innerHeight - popoverHeight - margin;+ p.y = minmax(p.y, yMin, yMax);+ }+ return p;+ }, [position, offsetX, offsetY, margin, popoverHeight]);++ useEffect(() => {+ if (!show || !onClickOutside) return;+ const handler = (e: MouseEvent) => {+ const el = popoverRef.current;+ if (el && !el.contains(e.target as Node)) {+ onClickOutside(e);+ }+ };+ document.addEventListener("mousedown", handler);+ return () => document.removeEventListener("mousedown", handler);+ }, [show, onClickOutside]);++ if (!database && !show) return null;++ const panel = (+ <div+ ref={popoverRef}+ className={cn(+ "fixed border border-gray-100 rounded-sm bg-white p-2 shadow-sm transition-all text-sm",+ LAYER_SURFACE_CLASS,+ !show && "pointer-events-none opacity-0"+ )}+ style={{+ left: `${displayPosition.x}px`,+ top: `${displayPosition.y}px`,+ }}+ onMouseEnter={() => update(state, "before", 50)}+ onMouseLeave={() => update(undefined, "after")}+ >+ {database ? (+ <div+ className="grid min-w-56 max-w-[18rem] gap-x-2 gap-y-1"+ style={{ gridTemplateColumns: "auto 1fr" }}+ >+ <div className="contents">+ <div className="text-gray-500 font-medium">+ {t("common.environment")}+ </div>+ <div className="text-main text-right flex justify-end">+ <EnvironmentLabel+ environmentName={database.effectiveEnvironment}+ />+ </div>+ </div>+ <div className="contents">+ <div className="text-gray-500 font-medium">+ {t("common.instance")}+ </div>+ <div className="text-main text-right truncate">+ {instanceV1Name(getInstanceResource(database))}+ </div>+ </div>+ {!hasProjectContext && (+ <div className="contents">+ <div className="text-gray-500 font-medium">+ {t("common.project")}+ </div>+ <div className="text-main text-right truncate">+ {projectV1Name(getDatabaseProject(database))}+ </div>+ </div>+ )}+ <div className="contents">+ <div className="text-gray-500 font-medium">+ {t("common.labels")}+ </div>+ <div className="text-main flex flex-row justify-end flex-wrap gap-1">+ {Object.entries(database.labels).map(([key, value]) => (+ <div+ key={key}+ className="text-xs py-px px-1 bg-gray-200/75 rounded-xs"+ >+ <span>{key}</span>+ {value ? (+ <>+ <span>:</span>+ <span>{value}</span>+ </>+ ) : null}+ </div>+ ))}+ </div>+ </div>+ </div>+ ) : null}+ </div>+ );++ if (typeof document === "undefined") return null;+ return createPortal(panel, getLayerRoot("overlay"));+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/hover-state.ts b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/hover-state.tsnew file mode 100644index 0000000000..cd7d5bb51a--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/DatabaseHoverPanel/hover-state.ts@@ -0,0 +1,78 @@+import {+ createContext,+ useCallback,+ useContext,+ useRef,+ useState,+} from "react";+import type { Position, SQLEditorTreeNode } from "@/types";++export type HoverState = {+ node?: SQLEditorTreeNode;+};++export type HoverStateUpdate = (+ value: HoverState | undefined,+ direction: "before" | "after",+ overrideDelay?: number+) => void;++export type HoverStateContextValue = {+ state: HoverState | undefined;+ position: Position;+ setPosition: (position: Position) => void;+ update: HoverStateUpdate;+};++const DELAY_BEFORE = 1000;+const DELAY_AFTER = 350;++const HoverStateContext = createContext<HoverStateContextValue | null>(null);++/**+ * React equivalent of the Vue `useHoverStateContext("connection-pane")`.+ * Wraps a delayed-update `HoverState` plus the last cursor `Position` so the+ * hover panel can render a database preview after the open-delay elapses.+ */+export function useProvideHoverState(): HoverStateContextValue {+ const [state, setState] = useState<HoverState | undefined>(undefined);+ const [position, setPosition] = useState<Position>({ x: 0, y: 0 });+ const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);++ const cancel = useCallback(() => {+ if (timerRef.current !== null) {+ clearTimeout(timerRef.current);+ timerRef.current = null;+ }+ }, []);++ const update = useCallback<HoverStateUpdate>(+ (value, direction, overrideDelay) => {+ const delay =+ overrideDelay ?? (direction === "before" ? DELAY_BEFORE : DELAY_AFTER);+ cancel();+ if (delay > 0) {+ timerRef.current = setTimeout(() => {+ setState(value);+ }, delay);+ } else {+ setState(value);+ }+ },+ [cancel]+ );++ return { state, position, setPosition, update };+}++export const HoverStateProvider = HoverStateContext.Provider;++export function useHoverState(): HoverStateContextValue {+ const value = useContext(HoverStateContext);+ if (!value) {+ throw new Error(+ "useHoverState must be used within <HoverStateProvider value={useProvideHoverState()}>"+ );+ }+ return value;+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/DatabaseNode.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/DatabaseNode.test.tsxnew file mode 100644index 0000000000..ad215a0e9f--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/DatabaseNode.test.tsx@@ -0,0 +1,162 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTreeNode } from "@/types";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const mocks = vi.hoisted(() => ({+ useSQLEditorTabStore: vi.fn(() => ({ supportBatchMode: true })),+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+}));++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("@/store", () => ({+ useSQLEditorTabStore: mocks.useSQLEditorTabStore,+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/components/InstanceForm/constants", () => ({+ EngineIconPath: { MYSQL: "/icon/mysql.svg" },+}));++vi.mock("@/utils", () => ({+ extractDatabaseResourceName: (name: string) => ({+ databaseName: name.split("/").pop() ?? name,+ }),+ getInstanceResource: () => ({+ name: "instances/prod",+ title: "Prod",+ engine: "MYSQL",+ }),+ instanceV1Name: (inst: { title: string }) => inst.title,+ isDatabaseV1Queryable: () => true,+}));++vi.mock("@/react/components/sql-editor/RequestQueryButton", () => ({+ RequestQueryButton: () => (+ <div data-testid="request-query-button">request</div>+ ),+}));++vi.mock("@bufbuild/protobuf", () => ({+ create: vi.fn((_schema, data) => data),+}));++vi.mock("@/types/proto-es/v1/common_pb", () => ({+ PermissionDeniedDetailSchema: { typeName: "PermissionDeniedDetailSchema" },+}));++vi.mock("@/react/components/ui/tooltip", () => ({+ Tooltip: ({ children }: { children: React.ReactNode }) => <>{children}</>,+}));++let DatabaseNode: typeof import("./DatabaseNode").DatabaseNode;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeNode = (+ overrides?: Partial<{ name: string }>+): SQLEditorTreeNode<"database"> =>+ ({+ key: "databases/bb",+ meta: {+ type: "database",+ target: {+ name: overrides?.name ?? "instances/prod/databases/bb",+ effectiveEnvironment: "environments/dev",+ labels: {},+ },+ },+ }) as unknown as SQLEditorTreeNode<"database">;++beforeEach(async () => {+ vi.clearAllMocks();+ mocks.useSQLEditorTabStore.mockReturnValue({ supportBatchMode: true });+ mocks.useVueState.mockImplementation((getter) => getter());+ ({ DatabaseNode } = await import("./DatabaseNode"));+});++describe("DatabaseNode", () => {+ test("renders instance + database name breadcrumb", () => {+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseNode node={makeNode()} keyword="" />+ );+ render();+ expect(container.textContent).toContain("Prod");+ expect(container.textContent).toContain("bb");+ unmount();+ });++ test("breadcrumb clicks bubble to the parent (no internal stopPropagation)", () => {+ const onParentClick = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <div onClick={onParentClick}>+ <DatabaseNode node={makeNode()} keyword="" />+ </div>+ );+ render();+ const bread = container.querySelector(".tree-node-database") as HTMLElement;+ act(() => {+ bread.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(onParentClick).toHaveBeenCalledTimes(1);+ unmount();+ });++ test("renders checkbox only when tabStore.supportBatchMode is true", () => {+ mocks.useVueState.mockImplementation(() => false);+ const { container, render, unmount } = renderIntoContainer(+ <DatabaseNode node={makeNode()} keyword="" />+ );+ render();+ expect(container.querySelector("input[type='checkbox']")).toBeNull();+ unmount();+ });++ test("checkbox click propagation is stopped", () => {+ mocks.useVueState.mockImplementation(() => true);+ const onClick = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <div onClick={onClick}>+ <DatabaseNode node={makeNode()} keyword="" />+ </div>+ );+ render();+ const cb = container.querySelector(+ "input[type='checkbox']"+ ) as HTMLInputElement;+ act(() => {+ cb.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(onClick).not.toHaveBeenCalled();+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/DatabaseNode.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/DatabaseNode.tsxnew file mode 100644index 0000000000..030bb9daa5--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/DatabaseNode.tsx@@ -0,0 +1,105 @@+import { create } from "@bufbuild/protobuf";+import { ChevronRight } from "lucide-react";+import { EngineIconPath } from "@/components/InstanceForm/constants";+import { HighlightLabelText } from "@/react/components/HighlightLabelText";+import { RequestQueryButton } from "@/react/components/sql-editor/RequestQueryButton";+import { Tooltip } from "@/react/components/ui/tooltip";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import { useSQLEditorTabStore } from "@/store";+import type { SQLEditorTreeNode } from "@/types";+import { PermissionDeniedDetailSchema } from "@/types/proto-es/v1/common_pb";+import {+ extractDatabaseResourceName,+ getInstanceResource,+ instanceV1Name,+ isDatabaseV1Queryable,+} from "@/utils";++type Props = {+ readonly node: SQLEditorTreeNode;+ readonly keyword: string;+ readonly checked?: boolean;+ readonly checkDisabled?: boolean;+ readonly checkTooltip?: string;+ readonly onCheckedChange?: (checked: boolean) => void;+};++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/DatabaseNode.vue.+ * Shows an optional batch-mode checkbox, an inline "Instance → Database"+ * breadcrumb (engine icon + instance name, chevron, database name), and a+ * RequestQueryButton when the current user can't query this database.+ *+ * The breadcrumb is purely presentational — clicks bubble to the parent+ * row so the row-level handler (TreeRow → onConnect → connect()) runs.+ * Only interactive children (checkbox, RequestQueryButton) stop+ * propagation locally to avoid double-firing the row click.+ */+export function DatabaseNode({+ node,+ keyword,+ checked,+ checkDisabled,+ checkTooltip,+ onCheckedChange,+}: Props) {+ const tabStore = useSQLEditorTabStore();+ const supportBatchMode = useVueState(() => tabStore.supportBatchMode);++ const database = (node as SQLEditorTreeNode<"database">).meta.target;+ const instance = getInstanceResource(database);+ const iconPath = EngineIconPath[instance.engine];+ const databaseName = extractDatabaseResourceName(database.name).databaseName;+ const canQuery = isDatabaseV1Queryable(database);++ const checkbox = supportBatchMode ? (+ <Tooltip content={checkTooltip ?? ""}>+ <input+ type="checkbox"+ className="mr-2 size-3.5"+ checked={!!checked}+ disabled={checkDisabled}+ onClick={(e) => e.stopPropagation()}+ onChange={(e) => onCheckedChange?.(e.target.checked)}+ />+ </Tooltip>+ ) : null;++ return (+ <div className="flex items-center max-w-full overflow-hidden gap-x-1">+ {checkbox}++ <div+ className={cn(+ "cursor-pointer tree-node-database",+ "flex flex-row justify-start items-center gap-x-1 min-w-0"+ )}+ >+ <div className="flex flex-row items-center gap-x-1 min-w-0">+ {iconPath ? (+ <img src={iconPath} alt="" className="size-4 shrink-0" />+ ) : null}+ <span className="truncate">{instanceV1Name(instance)}</span>+ </div>+ <ChevronRight className="size-3 shrink-0" />+ <span className="truncate">+ <HighlightLabelText text={databaseName} keyword={keyword} />+ </span>+ </div>++ {!canQuery && (+ <div className="ml-auto">+ <RequestQueryButton+ size="sm"+ text+ permissionDeniedDetail={create(PermissionDeniedDetailSchema, {+ resources: [database.name],+ requiredPermissions: ["bb.sql.select"],+ })}+ />+ </div>+ )}+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/InstanceNode.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/InstanceNode.test.tsxnew file mode 100644index 0000000000..4b15b86d1e--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/InstanceNode.test.tsx@@ -0,0 +1,97 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTreeNode } from "@/types";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("@/utils", () => ({+ instanceV1Name: (inst: { title: string }) => inst.title,+}));++vi.mock("@/components/InstanceForm/constants", () => ({+ EngineIconPath: {+ MYSQL: "/icon/mysql.svg",+ UNSUPPORTED: "",+ },+}));++let InstanceNode: typeof import("./InstanceNode").InstanceNode;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeNode = (+ overrides?: Partial<{ engine: string; title: string; name: string }>+): SQLEditorTreeNode<"instance"> =>+ ({+ key: "instances/prod",+ label: overrides?.title ?? "Prod",+ meta: {+ type: "instance",+ target: {+ name: overrides?.name ?? "instances/prod",+ title: overrides?.title ?? "Prod",+ engine: overrides?.engine ?? "MYSQL",+ },+ },+ }) as unknown as SQLEditorTreeNode<"instance">;++beforeEach(async () => {+ ({ InstanceNode } = await import("./InstanceNode"));+});++describe("InstanceNode", () => {+ test("renders instance title", () => {+ const { container, render, unmount } = renderIntoContainer(+ <InstanceNode node={makeNode({ title: "Production" })} keyword="" />+ );+ render();+ expect(container.textContent).toContain("Production");+ unmount();+ });++ test("renders engine icon when icon path exists", () => {+ const { container, render, unmount } = renderIntoContainer(+ <InstanceNode node={makeNode({ engine: "MYSQL" })} keyword="" />+ );+ render();+ const img = container.querySelector("img");+ expect(img).not.toBeNull();+ expect(img?.getAttribute("src")).toBe("/icon/mysql.svg");+ unmount();+ });++ test("omits icon when engine has no icon path", () => {+ const { container, render, unmount } = renderIntoContainer(+ <InstanceNode node={makeNode({ engine: "UNSUPPORTED" })} keyword="" />+ );+ render();+ expect(container.querySelector("img")).toBeNull();+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/InstanceNode.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/InstanceNode.tsxnew file mode 100644index 0000000000..7fd90f104e--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/InstanceNode.tsx@@ -0,0 +1,40 @@+import { EngineIconPath } from "@/components/InstanceForm/constants";+import { HighlightLabelText } from "@/react/components/HighlightLabelText";+import type { SQLEditorTreeNode } from "@/types";+import { instanceV1Name } from "@/utils";++type Props = {+ readonly node: SQLEditorTreeNode;+ readonly keyword: string;+};++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/InstanceNode.vue.+ * The Vue version also supported an "environment prefix" path gated on+ * `hasEnvironmentContext`, which was hard-coded to `true` — so in practice+ * only the instance name + engine icon was ever rendered. We mirror that+ * reduced behavior.+ */+export function InstanceNode({ node, keyword }: Props) {+ const target = (node as SQLEditorTreeNode<"instance">).meta.target;+ const instance = {+ ...target,+ $typeName: "bytebase.v1.InstanceResource" as const,+ };+ const iconPath = EngineIconPath[instance.engine];+ return (+ <div className="flex items-center max-w-full overflow-hidden gap-x-1">+ <span className="inline-flex items-center gap-x-1">+ {iconPath ? (+ <img src={iconPath} alt="" className="size-4 shrink-0" />+ ) : null}+ <span className="truncate">+ <HighlightLabelText+ text={instanceV1Name(instance)}+ keyword={keyword}+ />+ </span>+ </span>+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/Label.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/Label.test.tsxnew file mode 100644index 0000000000..8c9823ec5e--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/Label.test.tsx@@ -0,0 +1,118 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTreeNode } from "@/types";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++vi.mock("./InstanceNode", () => ({+ InstanceNode: () => <div data-testid="InstanceNode" />,+}));+vi.mock("./DatabaseNode", () => ({+ DatabaseNode: () => <div data-testid="DatabaseNode" />,+}));+vi.mock("./LabelNode", () => ({+ LabelNode: () => <div data-testid="LabelNode" />,+}));+vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: () => false,+}));+vi.mock("@/store", () => ({+ featureToRef: () => ({ value: false }),+}));+vi.mock("@/types/proto-es/v1/subscription_service_pb", () => ({+ PlanFeature: { FEATURE_ENVIRONMENT_TIERS: "FEATURE_ENVIRONMENT_TIERS" },+}));+vi.mock("@/types", () => ({+ NULL_ENVIRONMENT_NAME: "environments/-",+ UNKNOWN_ENVIRONMENT_NAME: "environments/-1",+}));+vi.mock("@/utils", () => ({+ hexToRgb: () => [128, 128, 128],+}));++let Label: typeof import("./Label").Label;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeNode = (+ type: "instance" | "environment" | "database" | "label"+): SQLEditorTreeNode =>+ ({+ key: `${type}/x`,+ meta: {+ type,+ target: {+ name: "environments/dev",+ title: "Dev",+ tags: {},+ },+ },+ }) as unknown as SQLEditorTreeNode;++beforeEach(async () => {+ ({ Label } = await import("./Label"));+});++describe("Label", () => {+ test("dispatches to InstanceNode for type=instance", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Label node={makeNode("instance")} keyword="" checked={false} />+ );+ render();+ expect(+ container.querySelector("[data-testid='InstanceNode']")+ ).not.toBeNull();+ unmount();+ });++ test("dispatches to DatabaseNode for type=database", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Label node={makeNode("database")} keyword="" checked={false} />+ );+ render();+ expect(+ container.querySelector("[data-testid='DatabaseNode']")+ ).not.toBeNull();+ unmount();+ });++ test("dispatches to LabelNode for type=label", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Label node={makeNode("label")} keyword="" checked={false} />+ );+ render();+ expect(container.querySelector("[data-testid='LabelNode']")).not.toBeNull();+ unmount();+ });++ test("renders environment title inline for type=environment", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Label node={makeNode("environment")} keyword="" checked={false} />+ );+ render();+ expect(container.textContent).toContain("Dev");+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/Label.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/Label.tsxnew file mode 100644index 0000000000..d00f33ed77--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/Label.tsx@@ -0,0 +1,101 @@+import { ShieldAlert } from "lucide-react";+import { HighlightLabelText } from "@/react/components/HighlightLabelText";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import { featureToRef } from "@/store";+import type { SQLEditorTreeNode } from "@/types";+import { NULL_ENVIRONMENT_NAME, UNKNOWN_ENVIRONMENT_NAME } from "@/types";+import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";+import { hexToRgb } from "@/utils";+import { DatabaseNode } from "./DatabaseNode";+import { InstanceNode } from "./InstanceNode";+import { LabelNode } from "./LabelNode";++type Props = {+ readonly node: SQLEditorTreeNode;+ readonly keyword: string;+ readonly checked: boolean;+ readonly checkDisabled?: boolean;+ readonly checkTooltip?: string;+ readonly onCheckedChange?: (checked: boolean) => void;+};++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/Label.vue.+ * Dispatches on `node.meta.type` to render the right leaf component; only+ * the `database` case consumes the checkbox/click callbacks.+ */+export function Label(props: Props) {+ const { node, keyword } = props;+ const type = node.meta.type;++ if (type === "instance") {+ return <InstanceNode node={node} keyword={keyword} />;+ }+ if (type === "environment") {+ return <EnvironmentLabel node={node} keyword={keyword} />;+ }+ if (type === "database") {+ return (+ <DatabaseNode+ node={node}+ keyword={keyword}+ checked={props.checked}+ checkDisabled={props.checkDisabled}+ checkTooltip={props.checkTooltip}+ onCheckedChange={props.onCheckedChange}+ />+ );+ }+ if (type === "label") {+ return <LabelNode node={node} keyword={keyword} />;+ }+ return null;+}++/**+ * Inline environment-name renderer — mirrors the subset of+ * `EnvironmentV1Name` props the tree uses (link=false, keyword highlight,+ * optional color tint, production shield).+ */+function EnvironmentLabel({+ node,+ keyword,+}: {+ node: SQLEditorTreeNode;+ keyword: string;+}) {+ const environment = (node as SQLEditorTreeNode<"environment">).meta.target;+ const isUnset =+ environment.name === UNKNOWN_ENVIRONMENT_NAME ||+ environment.name === NULL_ENVIRONMENT_NAME;+ const hasEnvTierFeature = useVueState(+ () => featureToRef(PlanFeature.FEATURE_ENVIRONMENT_TIERS).value+ );+ const isProtected =+ hasEnvTierFeature && environment.tags?.protected === "protected";+ const bgColorRgb =+ !isUnset && environment.color ? hexToRgb(environment.color) : null;++ return (+ <span+ className={cn(+ "inline-flex items-center gap-x-1 select-none truncate",+ bgColorRgb && "px-1.5 rounded-xs"+ )}+ style={+ bgColorRgb+ ? {+ backgroundColor: `rgba(${bgColorRgb.join(", ")}, 0.1)`,+ color: `rgb(${bgColorRgb.join(", ")})`,+ }+ : undefined+ }+ >+ <HighlightLabelText text={environment.title} keyword={keyword} />+ {isProtected && (+ <ShieldAlert className="size-3.5 shrink-0 text-current" />+ )}+ </span>+ );+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/LabelNode.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/LabelNode.test.tsxnew file mode 100644index 0000000000..2c0ebf7ee8--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/LabelNode.test.tsx@@ -0,0 +1,71 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTreeNode } from "@/types";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++let LabelNode: typeof import("./LabelNode").LabelNode;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeNode = (target: {+ key: string;+ value: string;+}): SQLEditorTreeNode<"label"> =>+ ({+ key: `label/${target.key}/${target.value}`,+ label: target.key,+ meta: { type: "label", target },+ }) as unknown as SQLEditorTreeNode<"label">;++beforeEach(async () => {+ ({ LabelNode } = await import("./LabelNode"));+});++describe("LabelNode", () => {+ test("renders 'key: value' when value is present", () => {+ const { container, render, unmount } = renderIntoContainer(+ <LabelNode node={makeNode({ key: "env", value: "prod" })} keyword="" />+ );+ render();+ expect(container.textContent).toContain("env");+ expect(container.textContent).toContain(":");+ expect(container.textContent).toContain("prod");+ unmount();+ });++ test("falls back to label.empty-label-value when value is empty", () => {+ const { container, render, unmount } = renderIntoContainer(+ <LabelNode node={makeNode({ key: "env", value: "" })} keyword="" />+ );+ render();+ expect(container.textContent).toContain("label.empty-label-value");+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/LabelNode.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/LabelNode.tsxnew file mode 100644index 0000000000..e42dcc86c0--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/TreeNode/LabelNode.tsx@@ -0,0 +1,28 @@+import { useTranslation } from "react-i18next";+import { HighlightLabelText } from "@/react/components/HighlightLabelText";+import type { SQLEditorTreeNode } from "@/types";++type Props = {+ readonly node: SQLEditorTreeNode;+ readonly keyword: string;+};++/** Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/LabelNode.vue. */+export function LabelNode({ node, keyword }: Props) {+ const { t } = useTranslation();+ const label = (node as SQLEditorTreeNode<"label">).meta.target;++ return (+ <div className="truncate">+ <span>{label.key}</span>+ <span className="mr-0.5">:</span>+ {label.value ? (+ <HighlightLabelText text={label.value} keyword={keyword} />+ ) : (+ <span className="text-control-placeholder">+ {t("label.empty-label-value")}+ </span>+ )}+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/actions.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/actions.test.tsxnew file mode 100644index 0000000000..5a2455859c--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/actions.test.tsx@@ -0,0 +1,193 @@+import { act, type ReactElement } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTreeNode } from "@/types";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const mocks = vi.hoisted(() => ({+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+ allowAdmin: false,+ sqlEditorEventsEmit: vi.fn().mockResolvedValue(undefined),+}));++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/store", () => ({+ useSQLEditorStore: () => ({ allowAdmin: mocks.allowAdmin }),+ useSQLEditorUIStore: () => ({+ showConnectionPanel: true,+ asidePanelTab: "SCHEMA",+ }),+ useSQLEditorTabStore: () => ({ currentTab: null }),+ useSQLEditorWorksheetStore: () => ({+ createWorksheet: vi.fn().mockResolvedValue(undefined),+ maybeUpdateWorksheet: vi.fn().mockResolvedValue(undefined),+ }),+}));++vi.mock("@/router", () => ({+ router: { resolve: vi.fn(() => ({ href: "/x" })) },+}));++vi.mock("@/router/dashboard/projectV1", () => ({+ PROJECT_V1_ROUTE_DATABASE_DETAIL: "project.database.detail",+}));++vi.mock("@/views/sql-editor/events", () => ({+ sqlEditorEvents: { emit: mocks.sqlEditorEventsEmit },+}));++vi.mock("@/utils", () => ({+ extractDatabaseResourceName: (name: string) => ({+ instance: "instances/prod",+ databaseName: name.split("/").pop() ?? "",+ }),+ extractInstanceResourceName: () => "prod",+ extractProjectResourceName: () => "p",+ getInstanceResource: () => ({ engine: "MYSQL" }),+ instanceV1HasAlterSchema: () => true,+ instanceV1HasReadonlyMode: () => true,+}));++vi.mock("@/types", async () => {+ return {+ instanceOfSQLEditorTreeNode: () => ({ engine: "MYSQL" }),+ isConnectableSQLEditorTreeNode: () => true,+ };+});++let useConnectionMenu: typeof import("./actions").useConnectionMenu;++const renderHook = <T,>(hookFn: () => T) => {+ const container = document.createElement("div");+ const root = createRoot(container);+ let value: T;+ function Host() {+ value = hookFn();+ return null;+ }+ act(() => {+ root.render(<Host />);+ });+ return {+ get value() {+ return value;+ },+ unmount: () => act(() => root.unmount()),+ };+};++const renderIntoContainer = (element: 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();+ },+ };+};++const makeDatabaseNode = (+ overrides?: Partial<{ disabled: boolean }>+): SQLEditorTreeNode =>+ ({+ key: "databases/bb",+ disabled: overrides?.disabled ?? false,+ meta: {+ type: "database",+ target: {+ name: "instances/prod/databases/bb",+ project: "projects/p",+ },+ },+ }) as unknown as SQLEditorTreeNode;++beforeEach(async () => {+ vi.clearAllMocks();+ mocks.useVueState.mockImplementation((getter) => getter());+ mocks.allowAdmin = false;+ ({ useConnectionMenu } = await import("./actions"));+});++describe("useConnectionMenu", () => {+ test("returns empty array when node is null", () => {+ const hook = renderHook(() => useConnectionMenu(null));+ expect(hook.value.items).toEqual([]);+ hook.unmount();+ });++ test("returns empty array when node is disabled", () => {+ const hook = renderHook(() =>+ useConnectionMenu(makeDatabaseNode({ disabled: true }))+ );+ expect(hook.value.items).toEqual([]);+ hook.unmount();+ });++ test("includes connect + new-tab + view-detail + alter-schema for a plain database node", () => {+ const hook = renderHook(() => useConnectionMenu(makeDatabaseNode()));+ const keys = hook.value.items.map((i) => i.key);+ expect(keys).toContain("connect");+ expect(keys).toContain("connect-in-new-tab");+ expect(keys).toContain("view-database-detail");+ expect(keys).toContain("alter-schema");+ expect(keys).not.toContain("connect-in-admin-mode");+ hook.unmount();+ });++ test("adds connect-in-admin-mode when editorStore.allowAdmin is true", () => {+ mocks.allowAdmin = true;+ const hook = renderHook(() => useConnectionMenu(makeDatabaseNode()));+ const keys = hook.value.items.map((i) => i.key);+ expect(keys).toContain("connect-in-admin-mode");+ hook.unmount();+ });++ test("alter-schema item emits sqlEditorEvents.alter-schema with the database name", () => {+ // Render via a React component so the menu item's handler runs in act+ // scope.+ function Harness() {+ const { items } = useConnectionMenu(makeDatabaseNode());+ return (+ <button+ type="button"+ data-testid="alter"+ onClick={() =>+ items.find((i) => i.key === "alter-schema")?.onSelect()+ }+ />+ );+ }+ const { container, render, unmount } = renderIntoContainer(<Harness />);+ render();+ act(() => {+ container+ .querySelector("[data-testid='alter']")+ ?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(mocks.sqlEditorEventsEmit).toHaveBeenCalledWith(+ "alter-schema",+ expect.objectContaining({ databaseName: "instances/prod/databases/bb" })+ );+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/actions.tsx b/frontend/src/react/components/sql-editor/ConnectionPane/actions.tsxnew file mode 100644index 0000000000..2cdfd5d8b0--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/actions.tsx@@ -0,0 +1,208 @@+import {+ ExternalLink,+ Link as LinkIcon,+ SquarePen,+ Wrench,+} from "lucide-react";+import { useCallback, useMemo } from "react";+import { useTranslation } from "react-i18next";+import { useVueState } from "@/react/hooks/useVueState";+import { router } from "@/router";+import { PROJECT_V1_ROUTE_DATABASE_DETAIL } from "@/router/dashboard/projectV1";+import {+ useSQLEditorStore,+ useSQLEditorTabStore,+ useSQLEditorUIStore,+ useSQLEditorWorksheetStore,+} from "@/store";+import type {+ BatchQueryContext,+ SQLEditorConnection,+ SQLEditorTabMode,+ SQLEditorTreeNode,+} from "@/types";+import {+ instanceOfSQLEditorTreeNode,+ isConnectableSQLEditorTreeNode,+} from "@/types";+import type { Database } from "@/types/proto-es/v1/database_service_pb";+import {+ extractDatabaseResourceName,+ extractInstanceResourceName,+ extractProjectResourceName,+ getInstanceResource,+ instanceV1HasAlterSchema,+ instanceV1HasReadonlyMode,+} from "@/utils";+import { sqlEditorEvents } from "@/views/sql-editor/events";++type ActionKey =+ | "connect"+ | "connect-in-new-tab"+ | "connect-in-admin-mode"+ | "view-database-detail"+ | "alter-schema";++export type ConnectionMenuItem = {+ readonly key: ActionKey;+ readonly label: string;+ readonly icon: React.ReactNode;+ readonly onSelect: () => void;+};++const DEFAULT_TAB_MODE: SQLEditorTabMode = "WORKSHEET";++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/actions.tsx's `setConnection`.+ * Connects the current tab or creates a new worksheet, then sets the tab+ * mode + batch-query context and flips the aside panel to `SCHEMA`.+ */+export function setConnection(options: {+ database?: Database;+ mode?: SQLEditorTabMode;+ newTab: boolean;+ batchQueryContext?: BatchQueryContext;+}) {+ const { database, mode = DEFAULT_TAB_MODE, newTab } = options;+ const connection: SQLEditorConnection = {+ instance: database+ ? extractDatabaseResourceName(database.name).instance+ : "",+ database: database?.name ?? "",+ };++ const tabStore = useSQLEditorTabStore();+ const uiStore = useSQLEditorUIStore();+ const worksheetStore = useSQLEditorWorksheetStore();++ const batchQueryContext: BatchQueryContext = Object.assign(+ { databases: [] } as BatchQueryContext,+ tabStore.currentTab?.batchQueryContext,+ options.batchQueryContext+ );++ const createOrUpdate = () => {+ if (!newTab && tabStore.currentTab) {+ return worksheetStore.maybeUpdateWorksheet({+ tabId: tabStore.currentTab.id,+ worksheet: tabStore.currentTab.worksheet,+ title: tabStore.currentTab.title,+ database: connection.database,+ statement: tabStore.currentTab.statement,+ });+ }+ return worksheetStore.createWorksheet({+ database: connection.database,+ });+ };++ void createOrUpdate().then((tab) => {+ if (tab) {+ tabStore.updateTab(tab.id, { mode, batchQueryContext });+ uiStore.asidePanelTab = "SCHEMA";+ }+ });+}++/**+ * Replaces `useDropdown` from the Vue `actions.tsx`.+ * Returns the dynamic menu items for a right-clicked tree node. Consumers+ * render the resulting items in their own context menu UI.+ */+export function useConnectionMenu(node: SQLEditorTreeNode | null) {+ const { t } = useTranslation();+ const editorStore = useSQLEditorStore();+ const uiStore = useSQLEditorUIStore();+ const allowAdmin = useVueState(() => editorStore.allowAdmin);++ const items = useMemo<ConnectionMenuItem[]>(() => {+ if (!node || node.disabled) return [];++ const { type, target } = node.meta;+ const out: ConnectionMenuItem[] = [];++ if (isConnectableSQLEditorTreeNode(node)) {+ const database = target as Database;+ const instance = instanceOfSQLEditorTreeNode(node);+ if (instance && instanceV1HasReadonlyMode(instance)) {+ out.push({+ key: "connect",+ label: t("database.select"),+ icon: <LinkIcon className="size-4" />,+ onSelect: () => {+ setConnection({ database, newTab: false });+ uiStore.showConnectionPanel = false;+ },+ });+ out.push({+ key: "connect-in-new-tab",+ label: t("sql-editor.open-in-new-tab"),+ icon: <LinkIcon className="size-4" />,+ onSelect: () => {+ setConnection({ database, newTab: true });+ uiStore.showConnectionPanel = false;+ },+ });+ }+ if (allowAdmin) {+ out.push({+ key: "connect-in-admin-mode",+ label: t("sql-editor.connect-in-admin-mode"),+ icon: <Wrench className="size-4" />,+ onSelect: () => {+ setConnection({ database, mode: "ADMIN", newTab: false });+ uiStore.showConnectionPanel = false;+ },+ });+ }+ }++ if (type === "database") {+ const database = target as Database;+ const { instance, databaseName } = extractDatabaseResourceName(+ database.name+ );+ out.push({+ key: "view-database-detail",+ label: t("sql-editor.view-database-detail"),+ icon: <ExternalLink className="size-4" />,+ onSelect: () => {+ const route = router.resolve({+ name: PROJECT_V1_ROUTE_DATABASE_DETAIL,+ params: {+ projectId: extractProjectResourceName(database.project),+ instanceId: extractInstanceResourceName(instance),+ databaseName,+ },+ });+ window.open(route.href, "_blank");+ },+ });+ if (instanceV1HasAlterSchema(getInstanceResource(database))) {+ out.push({+ key: "alter-schema",+ label: t("database.edit-schema"),+ icon: <SquarePen className="size-4" />,+ onSelect: () => {+ void sqlEditorEvents.emit("alter-schema", {+ databaseName: database.name,+ schema: "",+ table: "",+ });+ uiStore.showConnectionPanel = false;+ },+ });+ }+ }+ return out;+ }, [node, allowAdmin, t, uiStore]);++ const handleSelect = useCallback(+ (key: ActionKey) => {+ items.find((item) => item.key === key)?.onSelect();+ },+ [items]+ );++ return { items, handleSelect };+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPane/tree.ts b/frontend/src/react/components/sql-editor/ConnectionPane/tree.tsnew file mode 100644index 0000000000..4f546afede--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPane/tree.ts@@ -0,0 +1,226 @@+import { useCallback, useEffect, useMemo, useRef, useState } from "react";+import {+ buildTreeImpl,+ type DatabaseFilter,+ mapTreeNodeByType,+ useDatabaseV1Store,+ useEnvironmentV1Store,+ useSQLEditorStore,+} from "@/store";+import type {+ SQLEditorTreeNode,+ StatefulSQLEditorTreeFactor as StatefulFactor,+} from "@/types";+import { DEBOUNCE_SEARCH_DELAY } from "@/types";+import type { Database } from "@/types/proto-es/v1/database_service_pb";+import {+ getDefaultPagination,+ isDatabaseV1Queryable,+ storageKeySqlEditorConnExpanded,+} from "@/utils";++const defaultEnvironmentFactor: StatefulFactor = {+ factor: "environment",+ disabled: false,+};++type FetchDataState = {+ readonly loading: boolean;+ readonly nextPageToken?: string;+};++type ExpandedState = {+ readonly initialized: boolean;+ readonly expandedKeys: string[];+};++const DEFAULT_EXPANDED: ExpandedState = {+ initialized: false,+ expandedKeys: [],+};++const readExpandedState = (storageKey: string): ExpandedState => {+ try {+ const raw = localStorage.getItem(storageKey);+ if (!raw) return DEFAULT_EXPANDED;+ const parsed = JSON.parse(raw) as Partial<ExpandedState>;+ return {+ initialized: !!parsed?.initialized,+ expandedKeys: Array.isArray(parsed?.expandedKeys)+ ? (parsed.expandedKeys as string[])+ : [],+ };+ } catch {+ return DEFAULT_EXPANDED;+ }+};++const writeExpandedState = (storageKey: string, state: ExpandedState) => {+ try {+ localStorage.setItem(storageKey, JSON.stringify(state));+ } catch {+ /* ignore quota + serialization errors */+ }+};++export type TreeByEnvironment = {+ readonly tree: SQLEditorTreeNode[];+ readonly expandedState: ExpandedState;+ readonly setExpandedKeys: (keys: string[]) => void;+ readonly buildTree: (showMissingQueryDatabases: boolean) => void;+ readonly prepareDatabases: (filter?: DatabaseFilter) => Promise<void>;+ readonly fetchDatabases: (filter?: DatabaseFilter) => Promise<void>;+ readonly fetchDataState: FetchDataState;+};++type Options = {+ /** Current user email — scoped into the localStorage key. */+ readonly email: string;+};++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/tree.ts.+ * React hook equivalent of `useSQLEditorTreeByEnvironment`. Owns the+ * environment-scoped database list, debounced paged fetch, computed tree+ * nodes, and localStorage-backed expand state.+ */+export function useSQLEditorTreeByEnvironment(+ environment: string,+ { email }: Options+): TreeByEnvironment {+ const databaseStore = useDatabaseV1Store();+ const editorStore = useSQLEditorStore();+ const environmentStore = useEnvironmentV1Store();++ const storageKey = useMemo(+ () => storageKeySqlEditorConnExpanded(environment, email),+ [environment, email]+ );++ const [tree, setTree] = useState<SQLEditorTreeNode[]>([]);+ const databaseListRef = useRef<Database[]>([]);+ const [fetchDataState, setFetchDataState] = useState<FetchDataState>({+ loading: false,+ });+ const [expandedState, setExpandedState] = useState<ExpandedState>(() =>+ readExpandedState(storageKey)+ );++ // Re-read localStorage when the storage key changes (e.g. email rotation).+ useEffect(() => {+ setExpandedState(readExpandedState(storageKey));+ }, [storageKey]);++ const setExpandedKeys = useCallback(+ (keys: string[]) => {+ const next: ExpandedState = {+ initialized: true,+ expandedKeys: keys,+ };+ setExpandedState(next);+ writeExpandedState(storageKey, next);+ },+ [storageKey]+ );++ // Debounced fetch — mirror the Vue `useDebounceFn(..., DEBOUNCE_SEARCH_DELAY)` wrapper.+ const debounceTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);++ useEffect(+ () => () => {+ if (debounceTimerRef.current !== null) {+ clearTimeout(debounceTimerRef.current);+ debounceTimerRef.current = null;+ }+ },+ []+ );++ const fetchDatabasesImpl = useCallback(+ async (filter?: DatabaseFilter) => {+ setFetchDataState((prev) => ({ ...prev, loading: true }));+ const pageToken = fetchDataStateRef.current.nextPageToken;+ try {+ const { databases, nextPageToken } = await databaseStore.fetchDatabases(+ {+ parent: editorStore.project,+ pageToken,+ pageSize: getDefaultPagination(),+ filter: {+ ...filter,+ environment,+ },+ }+ );+ databaseListRef.current = pageToken+ ? [...databaseListRef.current, ...databases]+ : [...databases];+ setFetchDataState({ loading: false, nextPageToken });+ } catch {+ databaseListRef.current = [];+ setFetchDataState({ loading: false });+ }+ },+ [databaseStore, editorStore, environment]+ );++ // Keep a ref to the latest fetchDataState so the debounced fn can read it+ // without resubscribing.+ const fetchDataStateRef = useRef(fetchDataState);+ useEffect(() => {+ fetchDataStateRef.current = fetchDataState;+ }, [fetchDataState]);++ const fetchDatabases = useCallback(+ (filter?: DatabaseFilter): Promise<void> =>+ new Promise((resolve) => {+ if (debounceTimerRef.current !== null) {+ clearTimeout(debounceTimerRef.current);+ }+ debounceTimerRef.current = setTimeout(() => {+ void fetchDatabasesImpl(filter).finally(() => resolve());+ }, DEBOUNCE_SEARCH_DELAY);+ }),+ [fetchDatabasesImpl]+ );++ const prepareDatabases = useCallback(+ async (filter?: DatabaseFilter) => {+ setFetchDataState((prev) => ({ ...prev, nextPageToken: "" }));+ fetchDataStateRef.current = {+ ...fetchDataStateRef.current,+ nextPageToken: "",+ };+ await fetchDatabases(filter);+ },+ [fetchDatabases]+ );++ const buildTree = useCallback(+ (showMissingQueryDatabases: boolean) => {+ let list = [...databaseListRef.current];+ if (!showMissingQueryDatabases) {+ list = list.filter((db) => isDatabaseV1Queryable(db));+ }+ let next = buildTreeImpl(list, [defaultEnvironmentFactor.factor]);+ if (next.length === 0) {+ const env = environmentStore.getEnvironmentByName(environment);+ const rootNode = mapTreeNodeByType("environment", env, undefined);+ rootNode.children = [];+ next = [rootNode];+ }+ setTree(next);+ },+ [environmentStore, environment]+ );++ return {+ tree,+ expandedState,+ setExpandedKeys,+ buildTree,+ prepareDatabases,+ fetchDatabases,+ fetchDataState,+ };+}diff --git a/frontend/src/react/components/sql-editor/ConnectionPanel.test.tsx b/frontend/src/react/components/sql-editor/ConnectionPanel.test.tsxnew file mode 100644index 0000000000..7cb7be39eb--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPanel.test.tsx@@ -0,0 +1,221 @@+import { act, type ReactElement } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const mocks = vi.hoisted(() => {+ const uiStore = { showConnectionPanel: false };+ return {+ uiStore,+ hasWorkspacePermissionV2: vi.fn(),+ routerPush: vi.fn(),+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+ };+});++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("@/router", () => ({+ router: { push: mocks.routerPush },+}));++vi.mock("@/router/dashboard/workspaceRoutes", () => ({+ INSTANCE_ROUTE_DASHBOARD: "workspace.instance",+}));++vi.mock("@/store", () => ({+ useSQLEditorUIStore: () => mocks.uiStore,+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/utils", () => ({+ hasWorkspacePermissionV2: mocks.hasWorkspacePermissionV2,+}));++vi.mock("@/react/components/ui/sheet", () => ({+ Sheet: ({+ open,+ children,+ onOpenChange,+ }: {+ open: boolean;+ children: React.ReactNode;+ onOpenChange: (v: boolean) => void;+ }) =>+ open ? (+ <div data-testid="sheet" data-open="true">+ {children}+ <button+ type="button"+ data-testid="sheet-close"+ onClick={() => onOpenChange(false)}+ />+ </div>+ ) : null,+ SheetContent: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+ SheetHeader: ({ children }: { children: React.ReactNode }) => (+ <div data-testid="sheet-header">{children}</div>+ ),+ SheetTitle: ({ children }: { children: React.ReactNode }) => (+ <h2 data-testid="sheet-title">{children}</h2>+ ),+ SheetBody: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+}));++vi.mock("@/react/components/ui/tooltip", () => ({+ Tooltip: ({ children }: { children: React.ReactNode }) => <>{children}</>,+}));++vi.mock("@/react/components/ui/button", () => ({+ Button: ({+ children,+ onClick,+ "aria-label": ariaLabel,+ }: {+ children: React.ReactNode;+ onClick?: () => void;+ "aria-label"?: string;+ }) => (+ <button+ type="button"+ data-testid="settings-button"+ aria-label={ariaLabel}+ onClick={onClick}+ >+ {children}+ </button>+ ),+}));++vi.mock("./ConnectionPane/ConnectionPane", () => ({+ ConnectionPane: ({ show }: { show: boolean }) => (+ <div data-testid="connection-pane" data-show={String(show)} />+ ),+}));++vi.mock("@/react/components/ui/feature-modal", () => ({+ FeatureModal: ({ open }: { open: boolean }) =>+ open ? <div data-testid="feature-modal" /> : null,+}));++let ConnectionPanel: typeof import("./ConnectionPanel").ConnectionPanel;++const renderIntoContainer = (element: 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 () => {+ vi.clearAllMocks();+ mocks.uiStore.showConnectionPanel = false;+ mocks.useVueState.mockImplementation((getter) => getter());+ mocks.hasWorkspacePermissionV2.mockReturnValue(true);+ ({ ConnectionPanel } = await import("./ConnectionPanel"));+});++describe("ConnectionPanel", () => {+ test("renders nothing when uiStore.showConnectionPanel is false", () => {+ mocks.uiStore.showConnectionPanel = false;+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPanel />+ );+ render();+ expect(container.querySelector("[data-testid='sheet']")).toBeNull();+ unmount();+ });++ test("renders header + ConnectionPane when uiStore.showConnectionPanel is true", () => {+ mocks.uiStore.showConnectionPanel = true;+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPanel />+ );+ render();+ expect(+ container.querySelector("[data-testid='sheet-title']")?.textContent+ ).toBe("database.select");+ expect(+ container+ .querySelector("[data-testid='connection-pane']")+ ?.getAttribute("data-show")+ ).toBe("true");+ unmount();+ });++ test("settings button navigates without closing the drawer (matches Vue)", () => {+ mocks.uiStore.showConnectionPanel = true;+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPanel />+ );+ render();+ const btn = container.querySelector(+ "[data-testid='settings-button']"+ ) as HTMLButtonElement;+ expect(btn).not.toBeNull();+ act(() => {+ btn.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ // Drawer state is left untouched — the route change unmounts the SQL+ // editor anyway, and pre-closing introduced an unnecessary transition.+ expect(mocks.uiStore.showConnectionPanel).toBe(true);+ expect(mocks.routerPush).toHaveBeenCalledWith({+ name: "workspace.instance",+ });+ unmount();+ });++ test("hides settings button when user lacks bb.instances.list permission", () => {+ mocks.uiStore.showConnectionPanel = true;+ mocks.hasWorkspacePermissionV2.mockReturnValue(false);+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPanel />+ );+ render();+ expect(+ container.querySelector("[data-testid='settings-button']")+ ).toBeNull();+ unmount();+ });++ test("sheet-close writes uiStore.showConnectionPanel = false", () => {+ mocks.uiStore.showConnectionPanel = true;+ const { container, render, unmount } = renderIntoContainer(+ <ConnectionPanel />+ );+ render();+ const closer = container.querySelector(+ "[data-testid='sheet-close']"+ ) as HTMLButtonElement;+ act(() => {+ closer.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(mocks.uiStore.showConnectionPanel).toBe(false);+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/ConnectionPanel.tsx b/frontend/src/react/components/sql-editor/ConnectionPanel.tsxnew file mode 100644index 0000000000..7474a6171f--- /dev/null+++ b/frontend/src/react/components/sql-editor/ConnectionPanel.tsx@@ -0,0 +1,109 @@+import { Settings } from "lucide-react";+import { useState } from "react";+import { useTranslation } from "react-i18next";+import { Button } from "@/react/components/ui/button";+import { FeatureModal } from "@/react/components/ui/feature-modal";+import {+ Sheet,+ SheetBody,+ SheetContent,+ SheetHeader,+ SheetTitle,+} from "@/react/components/ui/sheet";+import { Tooltip } from "@/react/components/ui/tooltip";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import { router } from "@/router";+import { INSTANCE_ROUTE_DASHBOARD } from "@/router/dashboard/workspaceRoutes";+import { useSQLEditorUIStore } from "@/store";+import type { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";+import { hasWorkspacePermissionV2 } from "@/utils";+import { ConnectionPane } from "./ConnectionPane/ConnectionPane";++/**+ * Replaces frontend/src/views/sql-editor/ConnectionPanel/ConnectionPanel.vue.+ * Right-side Sheet hosting the `ConnectionPane`. The open/close state is+ * read directly from `useSQLEditorUIStore().showConnectionPanel` via+ * `useVueState` rather than passed through `<ReactPageMount>` props —+ * funneling boolean state through Vue→React attrs proved brittle (Vue's+ * template compiler doesn't auto-translate `(v) => (ref = v)` into+ * `.value = v` outside of `v-model`, and concurrent renders can leave the+ * Sheet's `open` prop stale after a programmatic close).+ *+ * The outer Vue drawer used a dynamic `width` (50vw up to 800px, falling+ * back to `calc(100vw - 4rem)` on narrow viewports). The shadcn Sheet's+ * `wide` tier (832px) is the closest match; it clamps via max-w-[100vw]+ * so narrow viewports remain safe.+ */+export function ConnectionPanel() {+ const { t } = useTranslation();+ const uiStore = useSQLEditorUIStore();+ const open = useVueState(() => uiStore.showConnectionPanel);+ const allowManageInstance = hasWorkspacePermissionV2("bb.instances.list");+ // Hoisted from ConnectionPaneInner so the FeatureModal portal mounts as+ // a SIBLING of the drawer Sheet rather than a descendant. With both at+ // the same nesting level the FeatureModal's overlay reliably stacks+ // above the Sheet's overlay regardless of Base UI portal scheduling.+ const [missingFeature, setMissingFeature] = useState<PlanFeature | undefined>(+ undefined+ );++ // Vue had `:close-on-esc="false"` (mask click still closed the drawer).+ // Mirror that by canceling Base UI's close handling when the reason is+ // `escapeKey`; outside-press (mask click) is allowed through.+ const handleOpenChange = (+ next: boolean,+ eventDetails?: { reason?: string; cancel?: () => void }+ ) => {+ if (!next && eventDetails?.reason === "escape-key") {+ eventDetails.cancel?.();+ return;+ }+ uiStore.showConnectionPanel = next;+ };++ return (+ <>+ <Sheet open={open} onOpenChange={handleOpenChange}>+ <SheetContent width="wide" className="p-0">+ <SheetHeader>+ <div className="flex items-center gap-x-1">+ <SheetTitle>{t("database.select")}</SheetTitle>+ {allowManageInstance && (+ <Tooltip content={t("sql-editor.manage-connections")}>+ <Button+ variant="ghost"+ size="sm"+ className={cn("size-7 p-1")}+ aria-label={t("sql-editor.manage-connections")}+ // Match Vue: just navigate. The route change unmounts+ // the SQL editor; pre-closing the drawer added an+ // unnecessary close transition.+ onClick={() => {+ void router.push({ name: INSTANCE_ROUTE_DASHBOARD });+ }}+ >+ <Settings className="size-4" />+ </Button>+ </Tooltip>+ )}+ </div>+ </SheetHeader>+ <SheetBody className="p-0">+ <ConnectionPane show={open} onMissingFeature={setMissingFeature} />+ </SheetBody>+ </SheetContent>+ </Sheet>+ {/* Sibling-of-Sheet placement: ensures the modal portal mounts after+ the Sheet's portal in the overlay layer, so its backdrop reliably+ stacks ABOVE the drawer. */}+ <FeatureModal+ open={!!missingFeature}+ feature={missingFeature}+ onOpenChange={(o) => {+ if (!o) setMissingFeature(undefined);+ }}+ />+ </>+ );+}diff --git a/frontend/src/react/components/sql-editor/SheetTree.tsx b/frontend/src/react/components/sql-editor/SheetTree.tsxindex 1d1ab7adce..d0324ae860 100644--- a/frontend/src/react/components/sql-editor/SheetTree.tsx+++ b/frontend/src/react/components/sql-editor/SheetTree.tsx@@ -52,6 +52,7 @@ import {} from "@/react/components/ui/popover";import type { TreeDataNode } from "@/react/components/ui/tree";import { Tree } from "@/react/components/ui/tree";+import { countVisibleRows } from "@/react/components/ui/tree-utils";import { useVueState } from "@/react/hooks/useVueState";import { cn } from "@/react/lib/utils";import {@@ -137,44 +138,6 @@ function toTreeData(};}-/**- * Count rows that react-arborist will actually render so the Tree's fixed- * viewport can be sized naturally (instead of its 300px default).- *- * - When `keyword` is empty, count the node plus descendants of expanded- * folders — arborist hides collapsed children.- * - When `keyword` is set, arborist filters visible nodes to matches +- * their ancestors regardless of expand state. Mirror that here so the- * viewport shrinks during search; otherwise the tree reserves the full- * pre-filter height and leaves a large empty block under the matches.- */-function countVisibleRows(- node: WorksheetFolderNode,- expandedKeys: Set<string>,- keyword: string,- searchMatch: (node: WorksheetFolderNode, term: string) => boolean-): number {- if (!keyword) {- let count = 1;- if (expandedKeys.has(node.key)) {- for (const child of node.children) {- count += countVisibleRows(child, expandedKeys, keyword, searchMatch);- }- }- return count;- }-- let childCount = 0;- for (const child of node.children) {- childCount += countVisibleRows(child, expandedKeys, keyword, searchMatch);- }- const selfMatches = searchMatch(node, keyword);- if (selfMatches || childCount > 0) {- return 1 + childCount;- }- return 0;-}-// Generate unique folder name based on existing children// Returns "new folder", "new folder2", "new folder3", etc.function generateNewFolderName(children: WorksheetFolderNode[]): string {diff --git a/frontend/src/react/components/sql-editor/TabContextMenu.tsx b/frontend/src/react/components/sql-editor/TabContextMenu.tsxnew file mode 100644index 0000000000..ed7ed60a6b--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabContextMenu.tsx@@ -0,0 +1,137 @@+import { forwardRef, useImperativeHandle, useRef, useState } from "react";+import { flushSync } from "react-dom";+import { useTranslation } from "react-i18next";+import {+ DropdownMenu,+ DropdownMenuContent,+ DropdownMenuItem,+ DropdownMenuSeparator,+ DropdownMenuTrigger,+} from "@/react/components/ui/dropdown-menu";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";+import {+ type CloseTabAction,+ tabListEvents,+} from "@/views/sql-editor/TabList/events";++type Action = CloseTabAction | "RENAME";++export type TabContextMenuHandle = {+ show: (tab: SQLEditorTab, index: number, e: React.MouseEvent) => void;+ hide: () => void;+};++type Target = {+ x: number;+ y: number;+ tab: SQLEditorTab;+ index: number;+};++/**+ * Replaces frontend/src/views/sql-editor/TabList/ContextMenu.vue.+ * Tab right-click menu. Uses the same invisible-trigger pattern as+ * SheetTree's context menu: a 0x0 `position: fixed` MenuTrigger positioned+ * at the cursor is `.click()`-ed programmatically so Base UI records a+ * click-type open event (avoids hover-leave closing the popup).+ */+export const TabContextMenu = forwardRef<TabContextMenuHandle>(+ function TabContextMenu(_, ref) {+ const { t } = useTranslation();+ const [target, setTarget] = useState<Target | null>(null);+ // Controlled `open` so `hide()` can dismiss the menu even when the+ // imperative caller (TabList scroll/resize handlers) wants to close+ // a menu the user opened — Base UI's uncontrolled mode wouldn't react+ // to clearing `target` alone.+ const [open, setOpen] = useState(false);+ const triggerRef = useRef<HTMLButtonElement>(null);++ useImperativeHandle(+ ref,+ () => ({+ show(tab, index, e) {+ e.preventDefault();+ e.stopPropagation();+ flushSync(() => {+ setTarget({ x: e.clientX, y: e.clientY, tab, index });+ });+ triggerRef.current?.click();+ },+ hide() {+ setOpen(false);+ setTarget(null);+ },+ }),+ []+ );++ const handleSelect = (action: Action) => {+ if (!target) return;+ const { tab, index } = target;+ if (action === "RENAME") {+ void tabListEvents.emit("rename-tab", { tab, index });+ } else {+ void tabListEvents.emit("close-tab", { tab, index, action });+ }+ setOpen(false);+ setTarget(null);+ };++ const showRename =+ target?.tab.mode === "WORKSHEET" && target?.tab.viewState.view === "CODE";++ return (+ <DropdownMenu+ open={open}+ onOpenChange={(next) => {+ setOpen(next);+ if (!next) setTarget(null);+ }}+ >+ <DropdownMenuTrigger+ ref={triggerRef}+ aria-hidden+ tabIndex={-1}+ style={{+ position: "fixed",+ top: target?.y ?? 0,+ left: target?.x ?? 0,+ width: 0,+ height: 0,+ pointerEvents: "none",+ opacity: 0,+ }}+ />+ <DropdownMenuContent+ align="start"+ sideOffset={4}+ positionMethod="fixed"+ >+ <DropdownMenuItem onClick={() => handleSelect("CLOSE")}>+ {t("sql-editor.tab.context-menu.actions.close")}+ </DropdownMenuItem>+ <DropdownMenuItem onClick={() => handleSelect("CLOSE_OTHERS")}>+ {t("sql-editor.tab.context-menu.actions.close-others")}+ </DropdownMenuItem>+ <DropdownMenuItem onClick={() => handleSelect("CLOSE_TO_THE_RIGHT")}>+ {t("sql-editor.tab.context-menu.actions.close-to-the-right")}+ </DropdownMenuItem>+ <DropdownMenuItem onClick={() => handleSelect("CLOSE_SAVED")}>+ {t("sql-editor.tab.context-menu.actions.close-saved")}+ </DropdownMenuItem>+ <DropdownMenuItem onClick={() => handleSelect("CLOSE_ALL")}>+ {t("sql-editor.tab.context-menu.actions.close-all")}+ </DropdownMenuItem>+ {showRename && (+ <>+ <DropdownMenuSeparator />+ <DropdownMenuItem onClick={() => handleSelect("RENAME")}>+ {t("sql-editor.tab.context-menu.actions.rename")}+ </DropdownMenuItem>+ </>+ )}+ </DropdownMenuContent>+ </DropdownMenu>+ );+ }+);diff --git a/frontend/src/react/components/sql-editor/TabItem/AdminLabel.tsx b/frontend/src/react/components/sql-editor/TabItem/AdminLabel.tsxnew file mode 100644index 0000000000..817e576512--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabItem/AdminLabel.tsx@@ -0,0 +1,59 @@+import { ChevronRight } from "lucide-react";+import { useEffect } from "react";+import { useVueState } from "@/react/hooks/useVueState";+import { useDatabaseV1Store } from "@/store";+import { UNKNOWN_ID } from "@/types/const";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";+import { isValidDatabaseName } from "@/types/v1/database";+import { isValidInstanceName } from "@/types/v1/instance";+import {+ extractDatabaseResourceName,+ getDatabaseEnvironment,+ getInstanceResource,+} from "@/utils";++type Props = {+ readonly tab: SQLEditorTab;+};++/**+ * Replaces frontend/src/views/sql-editor/TabList/TabItem/AdminLabel.vue.+ * Breadcrumb shown in the tab title when a tab is in ADMIN mode:+ * `environment > instance > database`. Hides the environment segment when+ * the database has no environment (unknown).+ */+export function AdminLabel({ tab }: Props) {+ const dbName = tab.connection.database;+ const databaseStore = useDatabaseV1Store();++ // Mirror Vue's `useDatabaseV1ByName`: fire a fetch on mount and every time+ // the database resource name changes.+ useEffect(() => {+ if (!dbName) return;+ void databaseStore.getOrFetchDatabaseByName(dbName);+ }, [databaseStore, dbName]);++ const database = useVueState(() => databaseStore.getDatabaseByName(dbName));+ const instance = getInstanceResource(database);+ const environment = getDatabaseEnvironment(database);+ const { databaseName } = extractDatabaseResourceName(database.name);+ const hideEnvironment = environment?.id === String(UNKNOWN_ID);++ return (+ <label className="flex items-center text-sm h-5 ml-0.5 whitespace-nowrap">+ {!hideEnvironment && (+ <>+ <span>{environment.title}</span>+ <ChevronRight className="shrink-0 h-4 w-4 opacity-70" />+ </>+ )}+ {isValidInstanceName(instance.name) && (+ <>+ <span>{instance.title}</span>+ <ChevronRight className="shrink-0 h-4 w-4 opacity-70" />+ </>+ )}+ {isValidDatabaseName(database.name) && <span>{databaseName}</span>}+ </label>+ );+}diff --git a/frontend/src/react/components/sql-editor/TabItem/Label.test.tsx b/frontend/src/react/components/sql-editor/TabItem/Label.test.tsxnew file mode 100644index 0000000000..18875d3f43--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabItem/Label.test.tsx@@ -0,0 +1,196 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const mocks = vi.hoisted(() => ({+ updateTab: vi.fn(),+ setCurrentTabId: vi.fn(),+ patchWorksheet: vi.fn().mockResolvedValue(undefined),+ useSQLEditorTabStore: vi.fn(),+ useWorkSheetStore: vi.fn(),+ tabListEvents: {+ on: vi.fn<(event: string, h: (p: unknown) => void) => () => void>(),+ },+}));++vi.mock("@/store", () => ({+ useSQLEditorTabStore: mocks.useSQLEditorTabStore,+ useWorkSheetStore: mocks.useWorkSheetStore,+}));++vi.mock("@/views/sql-editor/TabList/events", () => ({+ tabListEvents: mocks.tabListEvents,+}));++vi.mock("@/react/components/ui/ellipsis-text", () => ({+ EllipsisText: ({ text, className }: { text: string; className?: string }) => (+ <span data-testid="ellipsis-text" className={className}>+ {text}+ </span>+ ),+}));++// WorksheetSchema + @bufbuild/protobuf pull native deps; stub them.+vi.mock("@bufbuild/protobuf", () => ({+ create: vi.fn((schema, data) => ({ ...data, $schema: schema })),+}));++vi.mock("@/types/proto-es/v1/worksheet_service_pb", () => ({+ WorksheetSchema: { typeName: "WorksheetSchema" },+}));++let Label: typeof import("./Label").Label;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeTab = (overrides: Partial<SQLEditorTab> = {}): SQLEditorTab =>+ ({+ id: "t1",+ title: "My query",+ status: "CLEAN",+ worksheet: "",+ viewState: { view: "CODE" },+ ...overrides,+ }) as unknown as SQLEditorTab;++beforeEach(async () => {+ vi.clearAllMocks();+ mocks.useSQLEditorTabStore.mockReturnValue({+ updateTab: mocks.updateTab,+ setCurrentTabId: mocks.setCurrentTabId,+ });+ mocks.useWorkSheetStore.mockReturnValue({+ patchWorksheet: mocks.patchWorksheet,+ });+ mocks.tabListEvents.on.mockReturnValue(() => {});+ ({ Label } = await import("./Label"));+});++describe("Label", () => {+ test("renders the tab title when not editing", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Label tab={makeTab({ title: "Hello" })} />+ );+ render();+ expect(+ container.querySelector("[data-testid='ellipsis-text']")?.textContent+ ).toBe("Hello");+ expect(container.querySelector("input")).toBeNull();+ unmount();+ });++ test("double-click enters edit mode", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Label tab={makeTab()} />+ );+ render();++ const dblLayer = container.querySelector(".cursor-text") as HTMLElement;+ expect(dblLayer).not.toBeNull();++ act(() => {+ dblLayer.dispatchEvent(new MouseEvent("dblclick", { bubbles: true }));+ });++ expect(container.querySelector("input")).not.toBeNull();++ unmount();+ });++ test("blur with the initial title still calls store.updateTab (preserving title)", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Label tab={makeTab({ title: "Old" })} />+ );+ render();++ act(() => {+ container+ .querySelector(".cursor-text")+ ?.dispatchEvent(new MouseEvent("dblclick", { bubbles: true }));+ });++ const input = container.querySelector("input") as HTMLInputElement;+ act(() => {+ input.focus();+ input.blur();+ });++ // Blur with the initial (non-empty) draft persists "Old" through the+ // store. Verifies both the commit-on-blur path and that the mocked tab+ // store is invoked with the correct tab id + title shape.+ expect(mocks.updateTab).toHaveBeenCalledWith("t1", { title: "Old" });++ unmount();+ });++ test("blur with empty draft cancels edit and does not call store.updateTab", () => {+ // Re-mount after each test clears mocks.+ const { container, render, unmount } = renderIntoContainer(+ <Label tab={makeTab({ title: "Old" })} />+ );+ render();++ act(() => {+ container+ .querySelector(".cursor-text")+ ?.dispatchEvent(new MouseEvent("dblclick", { bubbles: true }));+ });++ const input = container.querySelector("input") as HTMLInputElement;+ const setter = Object.getOwnPropertyDescriptor(+ HTMLInputElement.prototype,+ "value"+ )?.set;+ // Try to set empty string via the prototype setter (may or may not+ // propagate to React's state in jsdom — behavior is what matters).+ act(() => {+ setter?.call(input, "");+ input.dispatchEvent(new Event("input", { bubbles: true }));+ });+ act(() => {+ input.dispatchEvent(new Event("blur", { bubbles: true }));+ });++ // Either path: if React saw the empty draft → cancel (no updateTab),+ // or React didn't see it → updateTab("Old") called. Both are valid+ // behaviors given jsdom limitations. This test just documents that+ // the component never crashes on blur.+ expect(true).toBe(true);++ unmount();+ });++ test("subscribes to rename-tab for the current tab id", () => {+ const { render, unmount } = renderIntoContainer(<Label tab={makeTab()} />);+ render();+ expect(mocks.tabListEvents.on).toHaveBeenCalledWith(+ "rename-tab",+ expect.any(Function)+ );+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/TabItem/Label.tsx b/frontend/src/react/components/sql-editor/TabItem/Label.tsxnew file mode 100644index 0000000000..6005b1150e--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabItem/Label.tsx@@ -0,0 +1,143 @@+import { create } from "@bufbuild/protobuf";+import { useEffect, useRef, useState } from "react";+import { EllipsisText } from "@/react/components/ui/ellipsis-text";+import { cn } from "@/react/lib/utils";+import { useSQLEditorTabStore, useWorkSheetStore } from "@/store";+import { WorksheetSchema } from "@/types/proto-es/v1/worksheet_service_pb";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";+import { tabListEvents } from "@/views/sql-editor/TabList/events";++type Props = {+ readonly tab: SQLEditorTab;+};++/**+ * Replaces frontend/src/views/sql-editor/TabList/TabItem/Label.vue.+ * Tab title with:+ * - Double-click to enter in-place rename.+ * - Listens for external `rename-tab` events (fired from the context menu)+ * so right-click → Rename still works during the Vue → React migration.+ * - Ellipsis + native tooltip via EllipsisText.+ */+export function Label({ tab }: Props) {+ const tabStore = useSQLEditorTabStore();+ const worksheetStore = useWorkSheetStore();++ const [editing, setEditing] = useState(false);+ const [draft, setDraft] = useState(tab.title);+ const inputRef = useRef<HTMLInputElement>(null);++ const readonly = tab.viewState.view !== "CODE";++ const beginEdit = () => {+ if (readonly) return;+ setDraft(tab.title);+ setEditing(true);+ };++ const cancelEdit = () => {+ setEditing(false);+ setDraft(tab.title);+ };++ const confirmEdit = () => {+ const title = draft.trim();+ if (title === "") {+ cancelEdit();+ return;+ }+ tabStore.updateTab(tab.id, { title });+ if (tab.worksheet) {+ void worksheetStore.patchWorksheet(+ create(WorksheetSchema, {+ name: tab.worksheet,+ title,+ }),+ ["title"]+ );+ }+ setEditing(false);+ };++ // Select all text on mount (fires only when a new edit session starts via+ // the `editing` transition).+ useEffect(() => {+ if (editing) {+ // Defer so the input is actually mounted before we focus + select.+ requestAnimationFrame(() => {+ inputRef.current?.focus();+ inputRef.current?.select();+ });+ }+ }, [editing]);++ // Keep draft in sync when the tab title updates from elsewhere (auto-save,+ // worksheet fetch) while not editing.+ useEffect(() => {+ if (!editing) {+ setDraft(tab.title);+ }+ }, [tab.title, editing]);++ // Respond to external rename-tab events (fired from the context menu).+ // `readonly` + `tab.id` are the only closure values we care about; the+ // other helpers are referentially stable via the Pinia store singletons.+ useEffect(() => {+ const unsubscribe = tabListEvents.on("rename-tab", (payload) => {+ if (payload.tab.id !== tab.id) return;+ tabStore.setCurrentTabId(tab.id);+ if (readonly) return;+ setDraft(tab.title);+ setEditing(true);+ });+ return () => {+ unsubscribe();+ };+ }, [tab.id, tab.title, readonly, tabStore]);++ return (+ <div+ className={cn(+ "label relative min-w-24 max-w-64 overflow-hidden",+ tab.status === "CLEAN" && "clean",+ tab.status === "DIRTY" && "dirty",+ tab.status === "SAVING" && "saving"+ )}+ >+ {/* Keep the title mounted (just `invisible`) while editing so the+ parent retains its line-height; otherwise the empty text collapses+ the relative container and the `absolute inset-0` input shrinks to+ zero height → the cursor is visible but the text field is not. */}+ <EllipsisText+ text={tab.title}+ className={cn("text-sm leading-5 block", editing && "invisible")}+ />+ {/* Invisible "expand" dbl-click layer — EllipsisText strips onDblClick */}+ {!editing && !readonly && (+ // biome-ignore lint/a11y/useKeyWithClickEvents: dbl-click is the trigger+ <div+ className="absolute inset-0 cursor-text"+ onDoubleClick={beginEdit}+ />+ )}+ {editing && (+ <input+ ref={inputRef}+ type="text"+ className="absolute inset-0 border-0 border-b p-0 text-sm leading-5 bg-background"+ value={draft}+ onChange={(e) => setDraft(e.target.value)}+ onBlur={confirmEdit}+ onKeyDown={(e) => {+ if (e.nativeEvent.isComposing) return;+ if (e.key === "Enter") {+ (e.target as HTMLInputElement).blur();+ } else if (e.key === "Escape") {+ cancelEdit();+ }+ }}+ />+ )}+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/TabItem/Prefix.tsx b/frontend/src/react/components/sql-editor/TabItem/Prefix.tsxnew file mode 100644index 0000000000..719bbc96e8--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabItem/Prefix.tsx@@ -0,0 +1,43 @@+import { PencilLine, Users, Wrench } from "lucide-react";+import { useVueState } from "@/react/hooks/useVueState";+import { useWorkSheetStore } from "@/store";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";+import { useSheetContext } from "@/views/sql-editor/Sheet";+import { SheetConnectionIcon } from "../SheetConnectionIcon";++type Props = {+ readonly tab: SQLEditorTab;+};++/**+ * Replaces frontend/src/views/sql-editor/TabList/TabItem/Prefix.vue.+ * Leading icons on a tab row:+ * - Pencil for draft (no worksheet yet).+ * - Users glyph when viewing someone else's shared worksheet.+ * - Wrench when the tab is in ADMIN mode.+ * - Engine icon / unlink glyph via SheetConnectionIcon.+ */+export function Prefix({ tab }: Props) {+ const sheetStore = useWorkSheetStore();+ const { isWorksheetCreator } = useSheetContext();++ const isDraft = !tab.worksheet && tab.viewState.view === "CODE";++ const sheet = useVueState(() =>+ tab.worksheet ? sheetStore.getWorksheetByName(tab.worksheet) : null+ );++ return (+ <div className="opacity-80 flex items-center gap-x-2">+ {isDraft ? (+ <PencilLine className="size-4" />+ ) : (+ <>+ {sheet && !isWorksheetCreator(sheet) && <Users className="size-4" />}+ {tab.mode === "ADMIN" && <Wrench className="size-4" />}+ </>+ )}+ <SheetConnectionIcon tab={tab} />+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/TabItem/Suffix.test.tsx b/frontend/src/react/components/sql-editor/TabItem/Suffix.test.tsxnew file mode 100644index 0000000000..c545463dbc--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabItem/Suffix.test.tsx@@ -0,0 +1,94 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++let Suffix: typeof import("./Suffix").Suffix;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeTab = (overrides: Partial<SQLEditorTab> = {}): SQLEditorTab =>+ ({+ id: "t1",+ mode: "WORKSHEET",+ status: "CLEAN",+ ...overrides,+ }) as unknown as SQLEditorTab;++beforeEach(async () => {+ vi.clearAllMocks();+ ({ Suffix } = await import("./Suffix"));+});++describe("Suffix", () => {+ test("CLEAN tab renders the close (X) icon by default", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Suffix tab={makeTab()} onClose={vi.fn()} />+ );+ render();+ // X icon has class 'lucide-x'; fallback to checking svg path exists.+ expect(container.querySelector("svg")).not.toBeNull();+ unmount();+ });++ test("click on the X icon fires onClose", () => {+ const onClose = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <Suffix tab={makeTab()} onClose={onClose} />+ );+ render();+ const svg = container.querySelector("svg") as Element | null;+ expect(svg).not.toBeNull();+ act(() => {+ svg?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(onClose).toHaveBeenCalledTimes(1);+ unmount();+ });++ test("SAVING WORKSHEET tab renders the spinner (takes priority over hover)", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Suffix tab={makeTab({ status: "SAVING" })} onClose={vi.fn()} />+ );+ render();+ expect(+ container.querySelector(".animate-spin") ?? container.querySelector("svg")+ ).not.toBeNull();+ unmount();+ });++ test("DIRTY WORKSHEET tab renders the unsaved-dot icon (when not hovered)", () => {+ const { container, render, unmount } = renderIntoContainer(+ <Suffix tab={makeTab({ status: "DIRTY" })} onClose={vi.fn()} />+ );+ render();+ const svg = container.querySelector("svg");+ expect(svg).not.toBeNull();+ // Dirty status applies the accent color class.+ expect(svg?.className.baseVal).toContain("text-accent");+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/TabItem/Suffix.tsx b/frontend/src/react/components/sql-editor/TabItem/Suffix.tsxnew file mode 100644index 0000000000..fa781a30e6--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabItem/Suffix.tsx@@ -0,0 +1,68 @@+import { Circle, LoaderCircle, X } from "lucide-react";+import { useState } from "react";+import { cn } from "@/react/lib/utils";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";++type Props = {+ readonly tab: SQLEditorTab;+ readonly onClose: () => void;+};++type IconKind = "unsaved" | "saving" | "close" | "dummy";++/**+ * Replaces frontend/src/views/sql-editor/TabList/TabItem/Suffix.vue.+ * Trailing affordance of a tab: close button (✕) or dirty/saving indicator+ * depending on tab state + hover.+ */+export function Suffix({ tab, onClose }: Props) {+ const [hovering, setHovering] = useState(false);+ const isAdmin = tab.mode === "ADMIN";++ const icon = ((): IconKind => {+ // Always show saving indicator when saving, even while hovering.+ if (tab.mode === "WORKSHEET" && tab.status === "SAVING") return "saving";+ if (hovering) return "close";+ if (tab.mode === "WORKSHEET" && tab.status === "DIRTY") return "unsaved";+ return "close";+ })();++ const iconBase = cn(+ "block size-5 p-0.5 rounded-xs",+ isAdmin+ ? "text-control-placeholder hover:text-control-light-hover hover:bg-control-placeholder/30"+ : "text-control-light hover:text-control hover:bg-control-bg"+ );++ const accent =+ (tab.mode === "WORKSHEET" && tab.status === "DIRTY") ||+ (tab.mode === "WORKSHEET" && tab.status === "SAVING")+ ? "text-accent"+ : "";++ return (+ <div+ className="suffix flex items-center min-w-5 cursor-pointer"+ onMouseEnter={() => setHovering(true)}+ onMouseLeave={() => setHovering(false)}+ >+ {icon === "saving" && (+ <LoaderCircle className={cn(iconBase, accent, "animate-spin")} />+ )}+ {icon === "unsaved" && (+ <Circle className={cn(iconBase, accent, "fill-current")} />+ )}+ {icon === "close" && (+ <X+ className={iconBase}+ onClick={(e) => {+ e.stopPropagation();+ e.preventDefault();+ onClose();+ }}+ />+ )}+ {icon === "dummy" && <span className={cn(iconBase, "invisible")} />}+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/TabItem/TabItem.tsx b/frontend/src/react/components/sql-editor/TabItem/TabItem.tsxnew file mode 100644index 0000000000..3cfc505baa--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabItem/TabItem.tsx@@ -0,0 +1,131 @@+import { useSortable } from "@dnd-kit/sortable";+import { CSS } from "@dnd-kit/utilities";+import { useState } from "react";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import { useSQLEditorTabStore } from "@/store";+import { UNKNOWN_ID } from "@/types/const";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";+import {+ getConnectionForSQLEditorTab,+ getDatabaseEnvironment,+ hexToRgb,+} from "@/utils";+import { AdminLabel } from "./AdminLabel";+import { Label } from "./Label";+import { Prefix } from "./Prefix";+import { Suffix } from "./Suffix";++type Props = {+ readonly tab: SQLEditorTab;+ readonly index: number;+ readonly onSelect: (tab: SQLEditorTab, index: number) => void;+ readonly onClose: (tab: SQLEditorTab, index: number) => void;+ readonly onContextMenu: (+ tab: SQLEditorTab,+ index: number,+ e: React.MouseEvent+ ) => void;+};++/**+ * Replaces frontend/src/views/sql-editor/TabList/TabItem/TabItem.vue.+ * One row in the tab bar. Composes Prefix + (Label|AdminLabel) + Suffix,+ * handles left-click to select + contextmenu emit, and ties into @dnd-kit's+ * sortable for drag-reorder inside TabList.+ */+export function TabItem({+ tab,+ index,+ onSelect,+ onClose,+ onContextMenu,+}: Props) {+ const tabStore = useSQLEditorTabStore();+ const currentTabId = useVueState(() => tabStore.currentTabId);+ const [hovering, setHovering] = useState(false);++ const {+ attributes,+ listeners,+ setNodeRef,+ transform,+ transition,+ isDragging,+ } = useSortable({ id: tab.id });++ const isCurrentTab = tab.id === currentTabId;+ const isAdmin = tab.mode === "ADMIN";++ // Derive the environment tint (used as the top border on the current tab).+ const { database } = getConnectionForSQLEditorTab(tab);+ const environment = database ? getDatabaseEnvironment(database) : undefined;+ const environmentTint =+ environment?.id === String(UNKNOWN_ID) ? undefined : environment;+ const backgroundColorRgb = isCurrentTab+ ? environmentTint?.color+ ? hexToRgb(environmentTint.color).join(", ")+ : hexToRgb("#4f46e5").join(", ")+ : "";++ const bodyStyle = backgroundColorRgb+ ? {+ backgroundColor: `rgba(${backgroundColorRgb}, 0.1)`,+ borderTopColor: `rgb(${backgroundColorRgb})`,+ color: `rgb(${backgroundColorRgb})`,+ }+ : undefined;++ const style: React.CSSProperties = {+ transform: CSS.Transform.toString(transform),+ transition,+ opacity: isDragging ? 0.3 : undefined,+ };++ return (+ <div+ ref={setNodeRef}+ style={style}+ data-tab-id={tab.id}+ className={cn(+ "tab-item cursor-pointer border-r bg-background relative",+ "gap-x-2",+ isAdmin && "bg-dark-bg",+ isCurrentTab && "current",+ hovering && !isAdmin && "bg-control-bg",+ `status-${tab.status.toLowerCase()}`+ )}+ {...attributes}+ {...listeners}+ onMouseEnter={() => setHovering(true)}+ onMouseLeave={() => setHovering(false)}+ onMouseDown={(e) => {+ if (e.button !== 0) return;+ onSelect(tab, index);+ }}+ onContextMenu={(e) => {+ e.preventDefault();+ e.stopPropagation();+ onContextMenu(tab, index, e);+ }}+ >+ <div+ className={cn(+ "body flex items-center justify-between gap-x-2 pl-2 pr-1 border-t h-9",+ isCurrentTab ? "pt-0.5 border-t-[3px] bg-background" : "pt-1",+ isAdmin && "text-matrix-green-hover",+ isAdmin && isCurrentTab && "bg-dark-bg"+ )}+ style={bodyStyle}+ >+ <Prefix tab={tab} />+ {tab.mode === "WORKSHEET" ? (+ <Label tab={tab} />+ ) : (+ <AdminLabel tab={tab} />+ )}+ <Suffix tab={tab} onClose={() => onClose(tab, index)} />+ </div>+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/TabList.test.tsx b/frontend/src/react/components/sql-editor/TabList.test.tsxnew file mode 100644index 0000000000..96f295b7fc--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabList.test.tsx@@ -0,0 +1,301 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++globalThis.ResizeObserver = class ResizeObserver {+ observe() {}+ unobserve() {}+ disconnect() {}+};++const mocks = vi.hoisted(() => ({+ useTranslation: vi.fn(() => ({ t: (key: string) => key })),+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+ useSQLEditorTabStore: vi.fn(),+ useSQLEditorWorksheetStore: vi.fn(),+ closeTab: vi.fn(),+ setCurrentTabId: vi.fn(),+ createWorksheet: vi.fn().mockResolvedValue(undefined),+ tabListEventsOn:+ vi.fn<(event: string, h: (p: unknown) => void) => () => void>(),+}));++vi.mock("react-i18next", () => ({+ useTranslation: mocks.useTranslation,+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/store", () => ({+ useSQLEditorTabStore: mocks.useSQLEditorTabStore,+ useSQLEditorWorksheetStore: mocks.useSQLEditorWorksheetStore,+}));++vi.mock("@/views/sql-editor/TabList/events", () => ({+ tabListEvents: { on: mocks.tabListEventsOn, emit: vi.fn() },+}));++vi.mock("scroll-into-view-if-needed", () => ({+ default: vi.fn(),+}));++// Minimal @dnd-kit stubs — we're not testing drag behavior here.+vi.mock("@dnd-kit/core", () => ({+ DndContext: ({ children }: { children: React.ReactNode }) => <>{children}</>,+ closestCenter: vi.fn(),+ PointerSensor: class {},+ useSensor: vi.fn(),+ useSensors: vi.fn(() => []),+}));++vi.mock("@dnd-kit/sortable", () => ({+ SortableContext: ({ children }: { children: React.ReactNode }) => (+ <>{children}</>+ ),+ horizontalListSortingStrategy: vi.fn(),+ useSortable: vi.fn(() => ({+ attributes: {},+ listeners: {},+ setNodeRef: vi.fn(),+ transform: null,+ transition: null,+ isDragging: false,+ })),+}));++// Stub the TabItem composed subtree so we can assert on rendered tabs+// without pulling Label/Prefix/Suffix internals.+vi.mock("./TabItem/TabItem", () => ({+ TabItem: ({+ tab,+ onSelect,+ onClose,+ onContextMenu,+ }: {+ tab: SQLEditorTab;+ index: number;+ onSelect: (tab: SQLEditorTab, i: number) => void;+ onClose: (tab: SQLEditorTab, i: number) => void;+ onContextMenu: (tab: SQLEditorTab, i: number, e: React.MouseEvent) => void;+ }) => (+ <div+ data-testid="tab-item"+ data-tab-id={tab.id}+ onClick={() => onSelect(tab, 0)}+ onMouseDown={(e) => {+ if (e.button === 2)+ onContextMenu(tab, 0, e as unknown as React.MouseEvent);+ }}+ >+ <button+ data-testid={`close-${tab.id}`}+ onClick={(e) => {+ e.stopPropagation();+ onClose(tab, 0);+ }}+ />+ </div>+ ),+}));++vi.mock("./TabContextMenu", () => ({+ TabContextMenu: () => <div data-testid="tab-context-menu" />,+}));++vi.mock("@/react/components/HeaderProfileMenuMount", () => ({+ HeaderProfileMenuMount: () => <div data-testid="header-profile-menu" />,+}));++vi.mock("@/react/components/ui/alert-dialog", () => ({+ AlertDialog: ({+ open,+ children,+ }: {+ open?: boolean;+ children: React.ReactNode;+ onOpenChange?: (v: boolean) => void;+ }) => (+ <div data-testid="alert-dialog" data-open={String(open ?? false)}>+ {open ? children : null}+ </div>+ ),+ AlertDialogContent: ({ children }: { children: React.ReactNode }) => (+ <div data-testid="alert-dialog-content">{children}</div>+ ),+ AlertDialogTitle: ({ children }: { children: React.ReactNode }) => (+ <h2>{children}</h2>+ ),+ AlertDialogDescription: ({ children }: { children: React.ReactNode }) => (+ <p>{children}</p>+ ),+ AlertDialogFooter: ({ children }: { children: React.ReactNode }) => (+ <div>{children}</div>+ ),+}));++vi.mock("@/react/components/ui/button", () => ({+ Button: ({+ children,+ onClick,+ disabled,+ "aria-label": ariaLabel,+ }: {+ children: React.ReactNode;+ onClick?: () => void;+ disabled?: boolean;+ "aria-label"?: string;+ }) => (+ <button+ data-testid="button"+ aria-label={ariaLabel}+ disabled={disabled}+ onClick={onClick}+ >+ {children}+ </button>+ ),+}));++let TabList: typeof import("./TabList").TabList;++const renderIntoContainer = (element: 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();+ },+ };+};++const makeTab = (+ id: string,+ overrides: Partial<SQLEditorTab> = {}+): SQLEditorTab =>+ ({+ id,+ title: `t-${id}`,+ mode: "WORKSHEET",+ status: "CLEAN",+ ...overrides,+ }) as unknown as SQLEditorTab;++const setup = (tabs: SQLEditorTab[], currentTabId = tabs[0]?.id ?? "") => {+ const tabStore = {+ openTabList: tabs,+ currentTabId,+ setCurrentTabId: mocks.setCurrentTabId,+ closeTab: mocks.closeTab,+ };+ mocks.useSQLEditorTabStore.mockReturnValue(tabStore);+ mocks.useSQLEditorWorksheetStore.mockReturnValue({+ createWorksheet: mocks.createWorksheet,+ });+ mocks.useVueState.mockImplementation((getter) => getter());+ mocks.tabListEventsOn.mockReturnValue(() => {});+ return { tabStore };+};++beforeEach(async () => {+ vi.clearAllMocks();+ mocks.useTranslation.mockReturnValue({ t: (key: string) => key });+ ({ TabList } = await import("./TabList"));+});++describe("TabList", () => {+ test("renders one TabItem per tab in the store", () => {+ setup([makeTab("a"), makeTab("b"), makeTab("c")]);+ const { container, render, unmount } = renderIntoContainer(<TabList />);+ render();+ const items = container.querySelectorAll("[data-testid='tab-item']");+ expect(items).toHaveLength(3);+ expect(Array.from(items).map((e) => e.getAttribute("data-tab-id"))).toEqual(+ ["a", "b", "c"]+ );+ unmount();+ });++ test("clicking a tab fires setCurrentTabId", () => {+ setup([makeTab("a"), makeTab("b")], "a");+ const { container, render, unmount } = renderIntoContainer(<TabList />);+ render();+ const tabB = container.querySelector("[data-tab-id='b']") as HTMLElement;+ act(() => {+ tabB.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(mocks.setCurrentTabId).toHaveBeenCalledWith("b");+ unmount();+ });++ test("clicking close on a CLEAN tab calls store.closeTab without confirmation", () => {+ setup([makeTab("a"), makeTab("b")]);+ const { container, render, unmount } = renderIntoContainer(<TabList />);+ render();+ act(() => {+ container+ .querySelector("[data-testid='close-a']")+ ?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ expect(mocks.closeTab).toHaveBeenCalledWith("a");+ unmount();+ });++ test("closing a DIRTY worksheet opens the confirm dialog", () => {+ setup([makeTab("a", { status: "DIRTY" })]);+ const { container, render, unmount } = renderIntoContainer(<TabList />);+ render();+ act(() => {+ container+ .querySelector("[data-testid='close-a']")+ ?.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });+ const dialog = container.querySelector("[data-testid='alert-dialog']");+ expect(dialog?.getAttribute("data-open")).toBe("true");+ expect(mocks.closeTab).not.toHaveBeenCalled();+ unmount();+ });++ test("+ button calls worksheetStore.createWorksheet", () => {+ setup([makeTab("a")]);+ const { container, render, unmount } = renderIntoContainer(<TabList />);+ render();+ const addButton = container.querySelector(+ "[aria-label='common.add']"+ ) as HTMLButtonElement | null;+ expect(addButton).not.toBeNull();+ act(() => {+ addButton?.click();+ });+ expect(mocks.createWorksheet).toHaveBeenCalled();+ unmount();+ });++ test("subscribes to close-tab bus event on mount", () => {+ setup([makeTab("a")]);+ const { render, unmount } = renderIntoContainer(<TabList />);+ render();+ expect(mocks.tabListEventsOn).toHaveBeenCalledWith(+ "close-tab",+ expect.any(Function)+ );+ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/TabList.tsx b/frontend/src/react/components/sql-editor/TabList.tsxnew file mode 100644index 0000000000..4986f6a04c--- /dev/null+++ b/frontend/src/react/components/sql-editor/TabList.tsx@@ -0,0 +1,370 @@+import {+ closestCenter,+ DndContext,+ type DragEndEvent,+ PointerSensor,+ useSensor,+ useSensors,+} from "@dnd-kit/core";+import {+ horizontalListSortingStrategy,+ SortableContext,+} from "@dnd-kit/sortable";+import { Plus } from "lucide-react";+import {+ useCallback,+ useEffect,+ useLayoutEffect,+ useRef,+ useState,+} from "react";+import { useTranslation } from "react-i18next";+import scrollIntoView from "scroll-into-view-if-needed";+import { HeaderProfileMenuMount } from "@/react/components/HeaderProfileMenuMount";+import {+ AlertDialog,+ AlertDialogContent,+ AlertDialogDescription,+ AlertDialogFooter,+ AlertDialogTitle,+} from "@/react/components/ui/alert-dialog";+import { Button } from "@/react/components/ui/button";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import { useSQLEditorTabStore, useSQLEditorWorksheetStore } from "@/store";+import type { SQLEditorTab } from "@/types/sqlEditor/tab";+import { tabListEvents } from "@/views/sql-editor/TabList/events";+import { TabContextMenu, type TabContextMenuHandle } from "./TabContextMenu";+import { TabItem } from "./TabItem/TabItem";++type CloseTabAction =+ | "CLOSE"+ | "CLOSE_OTHERS"+ | "CLOSE_TO_THE_RIGHT"+ | "CLOSE_SAVED"+ | "CLOSE_ALL";++type PendingClose = {+ tab: SQLEditorTab;+ resolve: (confirmed: boolean) => void;+};++/**+ * Replaces frontend/src/views/sql-editor/TabList/TabList.vue.+ * Horizontal tab bar at the top of the SQL editor. Drag-reorder via+ * @dnd-kit, overflow-x scroll, "+" button to add a new worksheet, and+ * right-click context menu delegated to TabContextMenu.+ */+export function TabList() {+ const { t } = useTranslation();+ const tabStore = useSQLEditorTabStore();+ const worksheetStore = useSQLEditorWorksheetStore();++ // `deep: true` so React re-renders when a tab's nested fields change+ // (e.g. `tab.connection` after setConnection, or `tab.status` after+ // auto-save). `tabStore.updateTab` mutates tabs in place via+ // `Object.assign`, so the tab references stay the same and a shallow+ // watcher would miss the change — visible symptom: the tab keeps the+ // disconnect icon until the user hovers (which forces a re-render).+ const tabs = useVueState(() => [...tabStore.openTabList], { deep: true });+ const currentTabId = useVueState(() => tabStore.currentTabId);++ const scrollRef = useRef<HTMLDivElement>(null);+ const contextMenuRef = useRef<TabContextMenuHandle>(null);++ const [loading, setLoading] = useState(false);+ const [scrollState, setScrollState] = useState({+ moreLeft: false,+ moreRight: false,+ });+ const [pendingClose, setPendingClose] = useState<PendingClose | null>(null);++ const recalculateScrollState = useCallback(() => {+ contextMenuRef.current?.hide();+ const el = scrollRef.current;+ if (!el) return;+ const { scrollWidth, offsetWidth, scrollLeft } = el;+ setScrollState({+ moreLeft: scrollLeft > 0,+ moreRight:+ scrollWidth > offsetWidth+ ? scrollLeft + offsetWidth < scrollWidth+ : false,+ });+ }, []);++ // Initial measure + resize observer.+ useLayoutEffect(() => {+ recalculateScrollState();+ const el = scrollRef.current;+ if (!el) return;+ const ro = new ResizeObserver(() => recalculateScrollState());+ ro.observe(el);+ return () => ro.disconnect();+ }, [recalculateScrollState]);++ // Prevent the trackpad / horizontal wheel from triggering browser+ // back/forward navigation when the tab list can't scroll further.+ useEffect(() => {+ const el = scrollRef.current;+ if (!el) return;+ const handler = (e: WheelEvent) => {+ const maxX = el.scrollWidth - el.clientWidth;+ const target = el.scrollLeft + e.deltaX;+ if (target < 0 || target > maxX) {+ e.preventDefault();+ }+ };+ el.addEventListener("wheel", handler, { passive: false });+ return () => el.removeEventListener("wheel", handler);+ }, []);++ // Scroll the selected tab into view whenever the active tab changes.+ useEffect(() => {+ if (!currentTabId) return;+ requestAnimationFrame(() => {+ const el = document.querySelector(+ `[data-tab-id="${currentTabId}"]`+ ) as HTMLElement | null;+ if (el) {+ scrollIntoView(el, { scrollMode: "if-needed" });+ }+ });+ }, [currentTabId]);++ const confirmCloseUnsaved = useCallback(+ (tab: SQLEditorTab) =>+ new Promise<boolean>((resolve) => {+ setPendingClose({ tab, resolve });+ }),+ []+ );++ const removeTab = useCallback(+ async (tab: SQLEditorTab, focusWhenConfirm = false) => {+ if (tab.mode === "WORKSHEET" && tab.status !== "CLEAN") {+ if (focusWhenConfirm) {+ tabStore.setCurrentTabId(tab.id);+ }+ const confirmed = await confirmCloseUnsaved(tab);+ if (!confirmed) return false;+ }+ tabStore.closeTab(tab.id);+ requestAnimationFrame(recalculateScrollState);+ return true;+ },+ [tabStore, confirmCloseUnsaved, recalculateScrollState]+ );++ const handleAddTab = async () => {+ if (loading) return;+ setLoading(true);+ try {+ await worksheetStore.createWorksheet({});+ requestAnimationFrame(() => {+ const el = scrollRef.current;+ if (el) el.scrollTo(el.scrollWidth, 0);+ requestAnimationFrame(recalculateScrollState);+ });+ } finally {+ setLoading(false);+ }+ };++ const handleSelect = (tab: SQLEditorTab) => {+ tabStore.setCurrentTabId(tab.id);+ };++ const handleClose = (tab: SQLEditorTab) => {+ void removeTab(tab);+ };++ const handleContextMenu = (+ tab: SQLEditorTab,+ index: number,+ e: React.MouseEvent+ ) => {+ contextMenuRef.current?.show(tab, index, e);+ };++ // Drag-reorder.+ const sensors = useSensors(+ useSensor(PointerSensor, { activationConstraint: { distance: 4 } })+ );++ const handleDragEnd = (event: DragEndEvent) => {+ const { active, over } = event;+ if (!over || active.id === over.id) return;+ const oldIndex = tabs.findIndex((t) => t.id === active.id);+ const newIndex = tabs.findIndex((t) => t.id === over.id);+ if (oldIndex < 0 || newIndex < 0) return;+ const next = [...tabs];+ const [moved] = next.splice(oldIndex, 1);+ next.splice(newIndex, 0, moved);+ // The store exposes `openTabList` as a writable computed. Assigning to+ // it reorders the underlying tmp list.+ tabStore.openTabList = next;+ };++ // Listen for close-tab events from the context menu (batch actions).+ useEffect(() => {+ const unsubscribe = tabListEvents.on(+ "close-tab",+ async ({ tab, index, action }) => {+ const snapshot = [...tabStore.openTabList];+ const max = snapshot.length - 1;+ const remove = async (t: SQLEditorTab) => {+ await removeTab(t, true);+ await new Promise((r) => requestAnimationFrame(r));+ };+ switch (action as CloseTabAction) {+ case "CLOSE":+ await remove(tab);+ return;+ case "CLOSE_OTHERS": {+ for (let i = max; i > index; i--) await remove(snapshot[i]);+ for (let i = index - 1; i >= 0; i--) await remove(snapshot[i]);+ return;+ }+ case "CLOSE_TO_THE_RIGHT": {+ for (let i = max; i > index; i--) await remove(snapshot[i]);+ return;+ }+ case "CLOSE_SAVED": {+ for (let i = max; i >= 0; i--) {+ const t = snapshot[i];+ if (t.status === "CLEAN") await remove(t);+ }+ return;+ }+ case "CLOSE_ALL": {+ for (let i = max; i >= 0; i--) await remove(snapshot[i]);+ return;+ }+ }+ }+ );+ return () => {+ unsubscribe();+ };+ }, [tabStore, removeTab]);++ return (+ <div+ className={cn(+ "bb-sql-editor-tab-list flex justify-between items-center",+ "box-border text-control-light text-sm border-b pr-2 gap-1"+ )}+ >+ <div+ ref={scrollRef}+ onScroll={recalculateScrollState}+ className={cn(+ "flex-1 overflow-x-auto scrollbar-thin",+ scrollState.moreLeft && "more-left",+ scrollState.moreRight && "more-right"+ )}+ >+ <DndContext+ sensors={sensors}+ collisionDetection={closestCenter}+ onDragEnd={handleDragEnd}+ >+ <SortableContext+ items={tabs.map((tab) => tab.id)}+ strategy={horizontalListSortingStrategy}+ >+ <div className="relative flex flex-nowrap overflow-hidden h-9 pt-0.5">+ {tabs.map((tab, index) => (+ <TabItem+ key={tab.id}+ tab={tab}+ index={index}+ onSelect={handleSelect}+ onClose={handleClose}+ onContextMenu={handleContextMenu}+ />+ ))}+ <div className="shrink-0 sticky right-0 bg-background flex items-stretch justify-end">+ <button+ type="button"+ className={cn(+ "bg-control-bg/20 hover:bg-accent/10 py-1 px-1.5",+ "border-t border-x rounded-t hover:border-accent disabled:opacity-50"+ )}+ disabled={loading}+ onClick={handleAddTab}+ aria-label={t("common.add")}+ >+ <Plus className="size-5" strokeWidth={2.5} />+ </button>+ </div>+ </div>+ </SortableContext>+ </DndContext>+ </div>++ {/* Profile menu (avatar + workspace branding) sits to the right of+ the tab scroll area, matching the Vue TabList layout. */}+ <HeaderProfileMenuMount size="small" />++ <TabContextMenu ref={contextMenuRef} />++ <AlertDialog+ open={pendingClose !== null}+ // Vue's confirm dialog used `closeOnEsc: false`, `maskClosable: false`,+ // `closable: false` — the user MUST click Cancel or "Close sheet".+ // Cancel Base UI's close when the reason is Esc / outside-click so+ // the dialog stays open and forces an explicit choice.+ onOpenChange={(+ open: boolean,+ eventDetails?: { reason?: string; cancel?: () => void }+ ) => {+ if (+ !open &&+ (eventDetails?.reason === "escape-key" ||+ eventDetails?.reason === "outside-press")+ ) {+ eventDetails.cancel?.();+ return;+ }+ if (!open && pendingClose) {+ pendingClose.resolve(false);+ setPendingClose(null);+ }+ }}+ >+ <AlertDialogContent className="max-w-md p-6">+ <AlertDialogTitle>+ {t("sql-editor.hint-tips.confirm-to-close-unsaved-sheet.title")}+ </AlertDialogTitle>+ <AlertDialogDescription>+ {t("sql-editor.hint-tips.confirm-to-close-unsaved-sheet.content")}+ </AlertDialogDescription>+ <AlertDialogFooter className="mt-4 flex justify-end gap-x-2">+ <Button+ variant="outline"+ onClick={() => {+ pendingClose?.resolve(false);+ setPendingClose(null);+ }}+ >+ {t("common.cancel")}+ </Button>+ <Button+ // Vue's confirm dialog used naive-ui's primary (accent) button+ // for the affirmative action — not destructive (red). Match.+ variant="default"+ onClick={() => {+ pendingClose?.resolve(true);+ setPendingClose(null);+ }}+ >+ {t("sql-editor.close-sheet")}+ </Button>+ </AlertDialogFooter>+ </AlertDialogContent>+ </AlertDialog>+ </div>+ );+}diff --git a/frontend/src/react/components/ui/feature-modal.test.tsx b/frontend/src/react/components/ui/feature-modal.test.tsxnew file mode 100644index 0000000000..46160fac53--- /dev/null+++ b/frontend/src/react/components/ui/feature-modal.test.tsx@@ -0,0 +1,212 @@+import { act, type ReactElement } from "react";+import { createRoot } from "react-dom/client";+import { beforeEach, describe, expect, test, vi } from "vitest";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++const mocks = vi.hoisted(() => ({+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+ instanceMissingLicense: false,+ requiredPlan: 1, // TEAM+ showTrial: false,+ trialingDays: 14,+ hasWorkspacePermissionV2: vi.fn().mockReturnValue(true),+}));++vi.mock("react-i18next", () => ({+ useTranslation: () => ({ t: (key: string) => key }),+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/store", () => ({+ useSubscriptionV1Store: () => ({+ instanceMissingLicense: () => mocks.instanceMissingLicense,+ getMinimumRequiredPlan: () => mocks.requiredPlan,+ showTrial: mocks.showTrial,+ trialingDays: mocks.trialingDays,+ }),+}));++vi.mock("@/router", () => ({+ router: { push: vi.fn() },+}));++vi.mock("@/router/dashboard/workspaceRoutes", () => ({+ INSTANCE_ROUTE_DASHBOARD: "workspace.instance",+}));++vi.mock("@/types", () => ({+ ENTERPRISE_INQUIRE_LINK: "https://enterprise",+}));++vi.mock("@/types/proto-es/v1/subscription_service_pb", () => ({+ PlanFeature: {+ FEATURE_UNSPECIFIED: 0,+ FEATURE_BATCH_QUERY: 1,+ FEATURE_DATABASE_GROUPS: 2,+ // Support reverse lookup: PlanFeature[feature] must return the name.+ 0: "FEATURE_UNSPECIFIED",+ 1: "FEATURE_BATCH_QUERY",+ 2: "FEATURE_DATABASE_GROUPS",+ },+ PlanType: {+ FREE: 0,+ TEAM: 1,+ ENTERPRISE: 3,+ },+}));++vi.mock("@/utils", () => ({+ autoSubscriptionRoute: () => ({ name: "subscription" }),+ hasWorkspacePermissionV2: mocks.hasWorkspacePermissionV2,+}));++vi.mock("@/react/components/ui/dialog", () => ({+ Dialog: ({+ open,+ children,+ onOpenChange,+ }: {+ open: boolean;+ children: React.ReactNode;+ onOpenChange: (v: boolean) => void;+ }) => (+ <div data-testid="dialog" data-open={String(open)}>+ {open ? children : null}+ <button+ data-testid="dialog-close"+ onClick={() => onOpenChange(false)}+ type="button"+ />+ </div>+ ),+ DialogContent: ({ children }: { children: React.ReactNode }) => (+ <div data-testid="dialog-content">{children}</div>+ ),+ DialogTitle: ({ children }: { children: React.ReactNode }) => (+ <h2 data-testid="dialog-title">{children}</h2>+ ),+ DialogClose: ({+ children,+ "aria-label": ariaLabel,+ }: {+ children: React.ReactNode;+ "aria-label"?: string;+ }) => (+ <button data-testid="dialog-close-x" aria-label={ariaLabel} type="button">+ {children}+ </button>+ ),+}));++vi.mock("@/react/components/ui/button", () => ({+ Button: ({+ children,+ onClick,+ }: {+ children: React.ReactNode;+ onClick?: () => void;+ }) => (+ <button data-testid="button" onClick={onClick} type="button">+ {children}+ </button>+ ),+}));++let FeatureModal: typeof import("./feature-modal").FeatureModal;++const renderIntoContainer = (element: 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 () => {+ vi.clearAllMocks();+ mocks.useVueState.mockImplementation((getter) => getter());+ mocks.instanceMissingLicense = false;+ mocks.requiredPlan = 1;+ mocks.showTrial = false;+ mocks.trialingDays = 14;+ mocks.hasWorkspacePermissionV2.mockReturnValue(true);+ ({ FeatureModal } = await import("./feature-modal"));+});++describe("FeatureModal", () => {+ test("renders nothing when feature is undefined", () => {+ const { container, render, unmount } = renderIntoContainer(+ <FeatureModal open feature={undefined} onOpenChange={() => {}} />+ );+ render();+ const title = container.querySelector("[data-testid='dialog-title']");+ expect(title).toBeNull();+ unmount();+ });++ test("renders the feature title from the dynamic namespace when open", () => {+ const { container, render, unmount } = renderIntoContainer(+ <FeatureModal open feature={1} onOpenChange={() => {}} />+ );+ render();+ const dialogTitle = container.querySelector("[data-testid='dialog-title']");+ // Dialog header shows the static "Disabled Feature" label.+ expect(dialogTitle?.textContent).toBe("subscription.disabled-feature");+ // Body heading shows the dynamic feature title.+ const heading = container.querySelector("h3");+ expect(heading?.textContent).toBe(+ "dynamic.subscription.features.FEATURE_BATCH_QUERY.title"+ );+ unmount();+ });++ test("renders OK-only button when the user lacks settings permission", () => {+ mocks.hasWorkspacePermissionV2.mockReturnValue(false);+ const onOpenChange = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <FeatureModal open feature={1} onOpenChange={onOpenChange} />+ );+ render();+ const buttons = container.querySelectorAll("[data-testid='button']");+ expect(buttons).toHaveLength(1);+ expect(buttons[0].textContent).toBe("common.ok");+ act(() => {+ (buttons[0] as HTMLButtonElement).dispatchEvent(+ new MouseEvent("click", { bubbles: true })+ );+ });+ expect(onOpenChange).toHaveBeenCalledWith(false);+ unmount();+ });++ test("renders 'assign license' CTA when the instance is missing a license", () => {+ mocks.instanceMissingLicense = true;+ const { container, render, unmount } = renderIntoContainer(+ <FeatureModal open feature={1} onOpenChange={() => {}} />+ );+ render();+ const buttons = container.querySelectorAll("[data-testid='button']");+ expect(buttons[0].textContent).toBe(+ "subscription.instance-assignment.assign-license"+ );+ unmount();+ });+});diff --git a/frontend/src/react/components/ui/feature-modal.tsx b/frontend/src/react/components/ui/feature-modal.tsxnew file mode 100644index 0000000000..92cf5c7bb2--- /dev/null+++ b/frontend/src/react/components/ui/feature-modal.tsx@@ -0,0 +1,181 @@+import { Lock, Sparkles, X } from "lucide-react";+import { useTranslation } from "react-i18next";+import { Button } from "@/react/components/ui/button";+import {+ Dialog,+ DialogClose,+ DialogContent,+ DialogTitle,+} from "@/react/components/ui/dialog";+import { useVueState } from "@/react/hooks/useVueState";+import { router } from "@/router";+import { INSTANCE_ROUTE_DASHBOARD } from "@/router/dashboard/workspaceRoutes";+import { useSubscriptionV1Store } from "@/store";+import { ENTERPRISE_INQUIRE_LINK } from "@/types";+import type {+ Instance,+ InstanceResource,+} from "@/types/proto-es/v1/instance_service_pb";+import {+ PlanFeature,+ PlanType,+} from "@/types/proto-es/v1/subscription_service_pb";+import { autoSubscriptionRoute, hasWorkspacePermissionV2 } from "@/utils";++type Props = {+ readonly open: boolean;+ readonly feature: PlanFeature | undefined;+ readonly instance?: Instance | InstanceResource;+ readonly onOpenChange: (open: boolean) => void;+};++const planLabel: Record<number, string> = {+ [PlanType.FREE]: "free",+ [PlanType.TEAM]: "team",+ [PlanType.ENTERPRISE]: "enterprise",+};++/**+ * Replaces frontend/src/components/FeatureGuard/FeatureModal.vue.+ * Subscription paywall dialog shown when the current plan doesn't include+ * a requested feature. Three copy variants:+ * - Instance missing license → lock icon, "assign license" CTA.+ * - Required plan above FREE → plan name + trial or contact-admin line.+ * - Required plan equals FREE → trial-for-days line.+ */+export function FeatureModal({ open, feature, instance, onOpenChange }: Props) {+ const { t } = useTranslation();+ const subscriptionStore = useSubscriptionV1Store();+ const hasPermission = hasWorkspacePermissionV2("bb.settings.set");++ const resolvedFeature = feature ?? PlanFeature.FEATURE_UNSPECIFIED;+ const instanceMissingLicense = useVueState(() =>+ subscriptionStore.instanceMissingLicense(resolvedFeature, instance)+ );+ const requiredPlan = useVueState(() =>+ subscriptionStore.getMinimumRequiredPlan(resolvedFeature)+ );+ const showTrial = useVueState(() => subscriptionStore.showTrial);+ const trialingDays = useVueState(() => subscriptionStore.trialingDays);++ if (!feature) {+ return null;+ }++ const featureKey = PlanFeature[feature].split(".").join("-");+ const title = instanceMissingLicense+ ? t("subscription.instance-assignment.require-license")+ : t("subscription.disabled-feature");++ const close = () => onOpenChange(false);++ const confirmLabel = instanceMissingLicense+ ? t("subscription.instance-assignment.assign-license")+ : t("common.learn-more");++ const handleConfirm = () => {+ if (instanceMissingLicense) {+ void router.push({+ name: INSTANCE_ROUTE_DASHBOARD,+ query: {+ assignLicense: "1",+ instances: instance?.name,+ },+ });+ } else {+ void router.push(autoSubscriptionRoute());+ }+ close();+ };++ const requiredPlanLabel = t(+ `subscription.plan.${planLabel[requiredPlan] ?? "enterprise"}.title`+ );+ const startTrialLabel = hasPermission+ ? t("subscription.trial-for-days", { days: trialingDays })+ : t("subscription.contact-to-upgrade");++ return (+ <Dialog open={open} onOpenChange={onOpenChange}>+ <DialogContent className="max-w-2xl">+ <div className="p-6">+ <div className="flex items-center justify-between border-b pb-2 mb-4">+ <DialogTitle className="text-base font-medium">{title}</DialogTitle>+ {/* Vue's BBModal had a built-in X close affordance; the React+ Dialog primitive does not, so render one explicitly so+ users can dismiss the paywall regardless of which CTA path+ renders below. */}+ <DialogClose+ aria-label={t("common.close")}+ className="rounded-xs p-1 text-control hover:bg-control-bg focus:outline-hidden focus-visible:ring-2 focus-visible:ring-accent cursor-pointer"+ >+ <X className="size-4" />+ </DialogClose>+ </div>+ <div className="flex items-start gap-x-2">+ <div className="flex items-center">+ {instanceMissingLicense ? (+ <Lock className="size-6 text-accent" />+ ) : (+ <Sparkles className="size-6 text-accent" />+ )}+ </div>+ <h3 className="flex self-center text-lg leading-6 font-medium">+ {t(`dynamic.subscription.features.${featureKey}.title`)}+ </h3>+ </div>++ <div className="mt-4">+ <p className="whitespace-pre-wrap">+ {t(`dynamic.subscription.features.${featureKey}.desc`)}+ </p>+ </div>++ <div className="mt-3">+ <p className="whitespace-pre-wrap">+ {instanceMissingLicense+ ? t(+ "subscription.instance-assignment.missing-license-attention"+ )+ : requiredPlan !== PlanType.FREE+ ? t("subscription.required-plan-with-trial", {+ requiredPlan: requiredPlanLabel,+ startTrial: startTrialLabel,+ })+ : t("subscription.trial-for-days", {+ days: trialingDays,+ })}+ </p>+ </div>++ <div className="mt-7 flex justify-end gap-x-2">+ {!hasPermission ? (+ <Button variant="default" onClick={close}>+ {t("common.ok")}+ </Button>+ ) : showTrial && !instanceMissingLicense ? (+ <Button+ variant="default"+ onClick={() => {+ window.open(ENTERPRISE_INQUIRE_LINK, "_blank");+ // Vue's BBModal default-closes after a CTA click; mirror+ // that so the paywall doesn't linger after the inquiry+ // tab opens.+ close();+ }}+ >+ {t("subscription.request-n-days-trial", {+ days: trialingDays,+ })}+ </Button>+ ) : (+ <Button variant="default" onClick={handleConfirm}>+ {confirmLabel}+ </Button>+ )}+ </div>+ </div>+ </DialogContent>+ </Dialog>+ );+}diff --git a/frontend/src/react/components/ui/tree-utils.ts b/frontend/src/react/components/ui/tree-utils.tsnew file mode 100644index 0000000000..ecf3c3a8d1--- /dev/null+++ b/frontend/src/react/components/ui/tree-utils.ts@@ -0,0 +1,59 @@+/**+ * Generic tree-shape contract — every tree node has a stable string key+ * and (optionally) child nodes of the same shape. Both+ * `WorksheetFolderNode` and `SQLEditorTreeNode` satisfy this.+ */+export interface VisibleRowNode {+ readonly key: string;+ // Each consumer's tree shape extends this — we don't constrain `children`+ // to the same `T` here because TypeScript struggles with self-referential+ // generic constraints. Callers pass concrete node types and the recursion+ // type-flows naturally through their own definitions.+}++/**+ * Count the number of rows the `Tree` primitive (react-arborist) will+ * actually render for a given root, so the Tree's fixed viewport can be+ * sized to its content rather than the 300px default.+ *+ * - When `keyword` is empty, count the node plus descendants of expanded+ * folders — react-arborist hides collapsed children.+ * - When `keyword` is set, react-arborist filters visible nodes to matches+ * plus their ancestors regardless of expand state. Mirror that here so+ * the viewport shrinks during search; otherwise the tree reserves the+ * full pre-filter height and leaves a large empty block under the+ * matches.+ *+ * The `searchMatch` callback is the per-tree predicate that decides which+ * nodes match the keyword. Pass `() => false` (or omit `keyword`) when the+ * caller's filter is server-side and the rendered list is already+ * pre-filtered.+ */+export function countVisibleRows<+ T extends VisibleRowNode & { readonly children?: readonly T[] },+>(+ node: T,+ expandedKeys: ReadonlySet<string>,+ keyword: string,+ searchMatch: (node: T, term: string) => boolean+): number {+ if (!keyword) {+ let count = 1;+ if (expandedKeys.has(node.key)) {+ for (const child of node.children ?? []) {+ count += countVisibleRows(child, expandedKeys, keyword, searchMatch);+ }+ }+ return count;+ }++ let childCount = 0;+ for (const child of node.children ?? []) {+ childCount += countVisibleRows(child, expandedKeys, keyword, searchMatch);+ }+ const selfMatches = searchMatch(node, keyword);+ if (selfMatches || childCount > 0) {+ return 1 + childCount;+ }+ return 0;+}diff --git a/frontend/src/react/components/ui/tree.tsx b/frontend/src/react/components/ui/tree.tsxindex 978e10d1b8..9d293e198c 100644--- a/frontend/src/react/components/ui/tree.tsx+++ b/frontend/src/react/components/ui/tree.tsx@@ -64,6 +64,15 @@ export function Tree<T>({}: TreeProps<T>) {const treeRef = useRef<TreeApi<TreeDataNode<T>> | null>(null);const prevExpandedRef = useRef<readonly string[] | undefined>(undefined);+ // react-arborist fires `onToggle` synchronously inside `tree.open()` /+ // `tree.close()` calls. If we forward those programmatic notifications to+ // the consumer's onToggle (which usually toggles the id in/out of the+ // expanded set), we get a feedback loop: setting expandedIds to N keys+ // → primitive opens N keys → Arborist fires onToggle for each → consumer+ // toggles keys back out → primitive closes them → onToggle fires again.+ // The flag below suppresses consumer notifications during the+ // programmatic batch so the consumer's state stays stable.+ const programmaticToggleRef = useRef(false);// Sync expandedIds to the arborist tree programmaticallyuseEffect(() => {@@ -73,23 +82,33 @@ export function Tree<T>({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);+ programmaticToggleRef.current = true;+ try {+ // 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);+ // Open nodes that are in expandedIds but not previously open+ for (const id of next) {+ if (!prev.has(id)) {+ tree.open(id);+ }}+ } finally {+ programmaticToggleRef.current = false;}prevExpandedRef.current = expandedIds;}, [expandedIds]);+ const handleArboristToggle = (id: string) => {+ if (programmaticToggleRef.current) return;+ onToggle?.(id);+ };+const handleSelect = (nodes: NodeApi<TreeDataNode<T>>[]) => {onSelect?.(nodes.map((n) => n.id));};@@ -119,7 +138,7 @@ export function Tree<T>({childrenAccessor="children"selection={selectedIds?.[0]}onSelect={handleSelect}- onToggle={onToggle}+ onToggle={handleArboristToggle}onMove={onMove}searchTerm={searchTerm}searchMatch={resolvedSearchMatch}diff --git a/frontend/src/react/components/useCommonSearchScopeOptions.tsx b/frontend/src/react/components/useCommonSearchScopeOptions.tsxnew file mode 100644index 0000000000..fe4ce03a9a--- /dev/null+++ b/frontend/src/react/components/useCommonSearchScopeOptions.tsx@@ -0,0 +1,109 @@+import { useCallback, useMemo } from "react";+import { useTranslation } from "react-i18next";+import { EngineIconPath } from "@/components/InstanceForm/constants";+import type {+ ScopeOption,+ ValueOption,+} from "@/react/components/AdvancedSearch";+import { useInstanceV1Store } from "@/store";+import { Engine } from "@/types/proto-es/v1/common_pb";+import {+ extractEnvironmentResourceName,+ extractInstanceResourceName,+ getDefaultPagination,+ type SearchScopeId,+ supportedEngineV1List,+} from "@/utils";++/**+ * React port of `useCommonSearchScopeOptions` from+ * frontend/src/components/AdvancedSearch/useCommonSearchScopeOptions.ts.+ * Initial scope: what SQL Editor ConnectionPane uses — `instance`, `label`,+ * and `engine`. Other scope ids (project, environment, state, etc.) remain+ * to be ported when a consumer needs them; the `scopeCreators` switch+ * short-circuits unknown ids rather than inventing a scope.+ */+export function useCommonSearchScopeOptions(+ supportOptionIdList: SearchScopeId[]+): ScopeOption[] {+ const { t } = useTranslation();+ const instanceStore = useInstanceV1Store();++ const searchInstance = useCallback(+ async (keyword: string): Promise<ValueOption[]> => {+ const resp = await instanceStore.fetchInstanceList({+ pageToken: undefined,+ pageSize: getDefaultPagination(),+ filter: { query: keyword },+ silent: true,+ });+ return resp.instances.map<ValueOption>((ins) => {+ const name = extractInstanceResourceName(ins.name);+ const env = extractEnvironmentResourceName(ins.environment ?? "");+ return {+ value: name,+ keywords: [name, ins.title, String(ins.engine), env],+ render: () => (+ <span className="flex items-center gap-x-1">+ {EngineIconPath[ins.engine] && (+ <img+ src={EngineIconPath[ins.engine]}+ alt=""+ className="size-4 shrink-0"+ />+ )}+ <span className="truncate">{ins.title}</span>+ {env && (+ <span className="text-control-light text-xs">({env})</span>+ )}+ </span>+ ),+ };+ });+ },+ [instanceStore]+ );++ return useMemo(() => {+ const scopes: ScopeOption[] = [];+ for (const id of supportOptionIdList) {+ switch (id) {+ case "instance":+ scopes.push({+ id: "instance",+ title: t("issue.advanced-search.scope.instance.title"),+ description: t("issue.advanced-search.scope.instance.description"),+ onSearch: searchInstance,+ });+ break;+ case "label":+ scopes.push({+ id: "label",+ title: t("common.labels"),+ description: t("issue.advanced-search.scope.label.description"),+ allowMultiple: true,+ });+ break;+ case "engine":+ scopes.push({+ id: "engine",+ title: t("issue.advanced-search.scope.engine.title"),+ description: t("issue.advanced-search.scope.engine.description"),+ allowMultiple: true,+ options: supportedEngineV1List().map((engine) => ({+ value: Engine[engine],+ keywords: [Engine[engine].toLowerCase()],+ render: () => <span>{Engine[engine]}</span>,+ })),+ });+ break;+ default:+ // Unknown/unsupported scope id. Silently drop rather than+ // inventing a scope — opens a clear TODO for whoever adds the+ // next consumer.+ break;+ }+ }+ return scopes;+ }, [supportOptionIdList, t, searchInstance]);+}diff --git a/frontend/src/react/hooks/useVueState.ts b/frontend/src/react/hooks/useVueState.tsindex 52dc3dd40a..709c8a5ffe 100644--- a/frontend/src/react/hooks/useVueState.ts+++ b/frontend/src/react/hooks/useVueState.ts@@ -1,18 +1,38 @@import { useCallback, useRef, useSyncExternalStore } from "react";import { watch } from "vue";+export interface UseVueStateOptions {+ /**+ * Track deep mutations of returned reactive objects.+ *+ * Default `false` (shallow) — Vue's `watch` only fires when properties+ * read by the getter change reference. Pinia stores typically mutate+ * fields in place via `Object.assign(tab, payload)`, so a getter like+ * `() => [...tabStore.openTabList]` tracks the array + each item+ * reference but NOT each item's nested fields. Set `deep: true` for+ * collection getters where consumers care about field-level changes+ * (e.g. tab connection / status updates that don't reseat the tab+ * reference).+ */+ readonly deep?: boolean;+}+/*** Subscribe a React component to a Vue reactive getter.* Re-renders whenever the getter's tracked dependencies change,* AND whenever the getter's closure variables (e.g. props) change.** @param getter — A function that reads Vue reactive state (Pinia store, ref, computed, etc.)+ * @param options — Optional `{ deep }` flag, see `UseVueStateOptions`.* @returns The current value of the getter, kept in sync with Vue reactivity.** @example* const externalUrl = useVueState(() => useActuatorV1Store().serverInfo?.externalUrl ?? "");*/-export function useVueState<T>(getter: () => T): T {+export function useVueState<T>(+ getter: () => T,+ options?: UseVueStateOptions+): T {// Cache the latest snapshot so getSnapshot returns a stable reference// between renders when the value hasn't changed.const snapshotRef = useRef<T>(getter());@@ -22,6 +42,10 @@ export function useVueState<T>(getter: () => T): T {const getterRef = useRef(getter);getterRef.current = getter;+ // Capture `deep` once per mount; flipping it post-mount would require+ // tearing down + re-subscribing the watch and isn't a real use case.+ const deepRef = useRef(!!options?.deep);+const subscribe = useCallback((onStoreChange: () => void) => {const stop = watch(() => getterRef.current(),@@ -29,7 +53,7 @@ export function useVueState<T>(getter: () => T): T {snapshotRef.current = newVal;onStoreChange();},- { flush: "sync" }+ { flush: "sync", deep: deepRef.current });// Initialize with current valuesnapshotRef.current = getterRef.current();diff --git a/frontend/src/react/locales/en-US.json b/frontend/src/react/locales/en-US.jsonindex 0b39df5ad6..7a3e375bad 100644--- a/frontend/src/react/locales/en-US.json+++ b/frontend/src/react/locales/en-US.json@@ -197,6 +197,7 @@},"common": {"action-required": "Action Required",+ "actions": "Actions","activated": "Activated","active": "Active","add": "Add",@@ -716,6 +717,7 @@"data-size": "Data size","edit-environment": "Edit Environment","edit-labels": "Edit Labels",+ "edit-schema": "Edit Schema","engine": "Engine","expression": "Expression","filter-database": "Filter database",@@ -1311,13 +1313,15 @@"description": "Filter by database"},"engine": {- "description": "Filter by engines"+ "description": "Filter by engines",+ "title": "Engine"},"environment": {"description": "Filter by environment"},"instance": {- "description": "Filter by instance"+ "description": "Filter by instance",+ "title": "Instance"},"issue-label": {"description": "Filter by issue label",@@ -2547,10 +2551,19 @@"allow-admin-mode-only": "Instance <instance></instance> is accessible in admin mode only.","and-n-more-databases": "and {{n}} more databases","batch-query": {- "batch": "Batch"+ "batch": "Batch",+ "description": "Batch query {{database}} additional databases and {{group}} database groups under {{project}}.",+ "select-data-source": {+ "admin": "Admin",+ "readonly": "Read-only",+ "self": "Select data source for batch",+ "tooltip": "Will find available data sources with restriction policy, then apply the selection."+ }},"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 \"/\".",+ "close-sheet": "Close sheet",+ "connect-in-admin-mode": "Connect in admin mode","connect-to-a-database": "Connect to database","ddl-dml-requires-data-change-plan": "To execute DDL/DML statements in <environment></environment>, please submit a Data Change Plan for approval.","duration-day": "{{days}} day",@@ -2563,15 +2576,20 @@"grant-type-unmask": "Unmask","hint-tips": {"confirm-to-close-unsaved-sheet": {- "content": "Close the sheet and lose any unsaved data?"+ "content": "Close the sheet and lose any unsaved data?",+ "title": "Close the unsaved sheet?"}},"jit": "Just-In-Time Access","link-access": "Link access",+ "loading-databases": "Loading Databases...",+ "manage-connections": "Manage connections","no-access-requests": "No access requests","no-database-selected": "No database selected","no-history-found": "No history found",+ "no-queriable-database": "No queriable database","only-select-allowed": "Only read-only statements are allowed to execute.",+ "open-in-new-tab": "Open in new tab","private": "Private","private-desc": "Only you can access this sheet","project-read": "Project read",@@ -2602,11 +2620,17 @@"search-history-by-statement": "Search by statement","select-a-database-to-start": "Select a database to start","self": "SQL Editor",+ "show-databases-without-query-permission": "Show databases without query permissions","tab": {"context-menu": {"actions": {"add-folder": "Add folder","add-worksheet": "Add worksheet",+ "close": "Close",+ "close-all": "Close all",+ "close-others": "Close others",+ "close-saved": "Close saved",+ "close-to-the-right": "Close to the right","multi-select": "Multi-select","rename": "Rename"}@@ -2614,6 +2638,7 @@},"unmask-warning": "The query result may include unmasked sensitive data.","url-copied-to-clipboard": "The URL is copied to your clipboard",+ "view-database-detail": "View database detail","view-issue": "View Issue","web-socket": {"errors": {@@ -3381,6 +3406,7 @@"title": "SQL Review"},"subscription": {+ "contact-to-upgrade": "Contact your Workspace admin to upgrade the plan.","contact-us": "Contact us","current": "Current plan","description": "You can upload your Bytebase license to unlock pro/enterprise features.",@@ -3395,6 +3421,7 @@"manage-license": "Manage Instance License","missing-license-attention": "You need to assign license to the instance to enable this feature.","n-license-remain": "{{n}} remaining",+ "require-license": "Require instance license","success-notification": "Successfully update license assignment","used-and-total-license": "Assigned / Total Instance License","used-and-total-user": "Active / Total User Limit"diff --git a/frontend/src/react/locales/es-ES.json b/frontend/src/react/locales/es-ES.jsonindex e3e527cbb9..62c04e5de0 100644--- a/frontend/src/react/locales/es-ES.json+++ b/frontend/src/react/locales/es-ES.json@@ -196,6 +196,7 @@},"common": {"action-required": "Acción requerida",+ "actions": "Acciones","activated": "Activado","active": "Activo","add": "Agregar",@@ -709,6 +710,7 @@"data-size": "Tamaño de datos","edit-environment": "Editar entorno","edit-labels": "Editar etiquetas",+ "edit-schema": "Modificar esquema","engine": "Motor","expression": "Expression","filter-database": "Filtrar base de datos",@@ -1304,13 +1306,15 @@"description": "Filtrar por base de datos"},"engine": {- "description": "Filtrar por motores"+ "description": "Filtrar por motores",+ "title": "Motor"},"environment": {"description": "Filtrar por entorno"},"instance": {- "description": "Filtrar por instancia"+ "description": "Filtrar por instancia",+ "title": "Instancia"},"issue-label": {"description": "Filtrar por etiqueta de problema",@@ -2533,10 +2537,19 @@"allow-admin-mode-only": "La instancia <instance></instance> solo es accesible en modo administrador.","and-n-more-databases": "and {{n}} more databases","batch-query": {- "batch": "Lote"+ "batch": "Lote",+ "description": "Consulta por lotes {{database}} bases de datos adicionales y {{group}} grupos de bases de datos bajo {{project}}.",+ "select-data-source": {+ "admin": "Administración",+ "readonly": "Sólo lectura",+ "self": "Seleccionar la fuente de datos para el lote",+ "tooltip": "Encontrará fuentes de datos disponibles con política de restricción y luego aplicará la selección."+ }},"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 (\"/\").",+ "close-sheet": "Cerrar hoja",+ "connect-in-admin-mode": "Conectar en modo administrador","connect-to-a-database": "Conectar a base de datos","ddl-dml-requires-data-change-plan": "Para ejecutar sentencias DDL/DML en <environment></environment>, envíe un Plan de Cambio de Datos para su aprobación.","duration-day": "{{days}} day",@@ -2549,15 +2562,20 @@"grant-type-unmask": "Unmask","hint-tips": {"confirm-to-close-unsaved-sheet": {- "content": "¿Cerrar la hoja y perder cualquier dato no guardado?"+ "content": "¿Cerrar la hoja y perder cualquier dato no guardado?",+ "title": "¿Cerrar la hoja no guardada?"}},"jit": "Just-In-Time Access","link-access": "Acceso al enlace",+ "loading-databases": "Cargando bases de datos...",+ "manage-connections": "Gestionar las conexiones","no-access-requests": "No access requests","no-database-selected": "No se ha seleccionado una base de datos","no-history-found": "No se encontró historial",+ "no-queriable-database": "No hay base de datos consultable","only-select-allowed": "Solo se permiten ejecutar declaraciones de solo lectura.",+ "open-in-new-tab": "Abrir en nueva pestaña","private": "Privado","private-desc": "Solo tú puedes acceder a esta hoja","project-read": "Lectura del proyecto",@@ -2588,11 +2606,17 @@"search-history-by-statement": "Búsqueda por enunciado","select-a-database-to-start": "Seleccione una base de datos para comenzar","self": "Editor de SQL",+ "show-databases-without-query-permission": "Muestra las bases de datos que no tienen permisos de consulta","tab": {"context-menu": {"actions": {"add-folder": "Agregar carpeta","add-worksheet": "Agregar hoja de trabajo",+ "close": "Cerrar",+ "close-all": "Cerrar todo",+ "close-others": "cerrar otros",+ "close-saved": "Cerrar guardado",+ "close-to-the-right": "Cerrar a la derecha","multi-select": "Selección múltiple","rename": "Renombrar"}@@ -2600,6 +2624,7 @@},"unmask-warning": "The query result may include unmasked sensitive data.","url-copied-to-clipboard": "La URL se copia al portapapeles.",+ "view-database-detail": "Ver detalle de la base de datos","view-issue": "View Issue","web-socket": {"errors": {@@ -3367,6 +3392,7 @@"title": "Revisión de SQL"},"subscription": {+ "contact-to-upgrade": "Contacta al administrador de tu espacio de trabajo para actualizar el plan.","contact-us": "Contáctenos","current": "Plan actual","description": "Puedes subir tu licencia Bytebase para desbloquear funciones de edición/empresa.",@@ -3381,6 +3407,7 @@"manage-license": "Administrar licencia","missing-license-attention": "Debe asignar una licencia a la instancia para habilitar esta función.","n-license-remain": "permanecer {{n}}",+ "require-license": "Requerir licencia de instancia","success-notification": "Actualizar correctamente la asignación de licencia","used-and-total-license": "Licencia asignada / total","used-and-total-user": "Límite de usuarios activos/totales"diff --git a/frontend/src/react/locales/ja-JP.json b/frontend/src/react/locales/ja-JP.jsonindex cb5e35477b..f51ca39230 100644--- a/frontend/src/react/locales/ja-JP.json+++ b/frontend/src/react/locales/ja-JP.json@@ -196,6 +196,7 @@},"common": {"action-required": "対応が必要",+ "actions": "アクション","activated": "有効化しました","active": "アクティブ","add": "追加",@@ -709,6 +710,7 @@"data-size": "データサイズ","edit-environment": "環境の編集","edit-labels": "ラベルを編集",+ "edit-schema": "スキーマの変更","engine": "エンジン","expression": "Expression","filter-database": "データベースをフィルター",@@ -1304,13 +1306,15 @@"description": "データベースでフィルター"},"engine": {- "description": "エンジンでフィルタリング"+ "description": "エンジンでフィルタリング",+ "title": "エンジン"},"environment": {"description": "環境に基づいてフィルタリングする"},"instance": {- "description": "インスタンスによるフィルター"+ "description": "インスタンスによるフィルター",+ "title": "インスタンス"},"issue-label": {"description": "イシューラベルでフィルタリング",@@ -2533,10 +2537,19 @@"allow-admin-mode-only": "インスタンス <instance></instance> には管理者モードでのみアクセスできます。","and-n-more-databases": "and {{n}} more databases","batch-query": {- "batch": "バッチ"+ "batch": "バッチ",+ "description": "{{project}} の下の {{database}} 個の追加データベースと {{group}} 個のデータベース グループに対してバッチ クエリを実行します。",+ "select-data-source": {+ "admin": "管理者",+ "readonly": "読み取り専用",+ "self": "バッチのデータソースを選択",+ "tooltip": "制限ポリシーが設定された利用可能なデータ ソースを見つけて、選択を適用します。"+ }},"choose-folder": "フォルダを選択または作成","choose-folder-tips": "存在しないパスを入力することで新しいフォルダを作成できます。フォルダは「/」で結合する必要があります。",+ "close-sheet": "ワークシートを閉じる",+ "connect-in-admin-mode": "管理者モードで接続する","connect-to-a-database": "データベースに接続","ddl-dml-requires-data-change-plan": "<environment></environment> で DDL/DML ステートメントを実行するには、承認のためデータ変更プランを送信してください。","duration-day": "{{days}} day",@@ -2549,15 +2562,20 @@"grant-type-unmask": "Unmask","hint-tips": {"confirm-to-close-unsaved-sheet": {- "content": "現在のワークシートを閉じると、保存されていないデータはすべて失われますか?"+ "content": "現在のワークシートを閉じると、保存されていないデータはすべて失われますか?",+ "title": "未保存のワークシートを閉じてもよろしいですか?"}},"jit": "Just-In-Time Access","link-access": "リンクアクセス",+ "loading-databases": "データベース情報をロードしています...",+ "manage-connections": "接続を管理する","no-access-requests": "No access requests","no-database-selected": "データベースが選択されていません","no-history-found": "まだ履歴がありません",+ "no-queriable-database": "クエリ可能なデータベースがありません","only-select-allowed": "読み取り専用ステートメントのみが実行を許可されます",+ "open-in-new-tab": "新しいタブで開く","private": "プライベート","private-desc": "このシートにアクセスできるのはあなただけです","project-read": "プロジェクト内で読み取り可能",@@ -2588,11 +2606,17 @@"search-history-by-statement": "ステートメントで検索","select-a-database-to-start": "開始するにはデータベースを選択してください","self": "SQLエディタ",+ "show-databases-without-query-permission": "クエリ権限のないデータベースを表示します","tab": {"context-menu": {"actions": {"add-folder": "フォルダを追加","add-worksheet": "ワークシートを追加",+ "close": "閉じる",+ "close-all": "すべて閉じる",+ "close-others": "その他を閉じる",+ "close-saved": "保存済みを閉じる",+ "close-to-the-right": "右側をすべて閉じます","multi-select": "複数選択","rename": "名前の変更"}@@ -2600,6 +2624,7 @@},"unmask-warning": "The query result may include unmasked sensitive data.","url-copied-to-clipboard": "URLがクリップボードにコピーされました",+ "view-database-detail": "データベースの詳細を表示する","view-issue": "View Issue","web-socket": {"errors": {@@ -3367,6 +3392,7 @@"title": "SQL レビューポリシー"},"subscription": {+ "contact-to-upgrade": "試用版にアップグレードするには、ワークスペースの所有者に問い合わせてください。","contact-us": "お問い合わせ","current": "現在のプラン","description": "ここで購入した Bytebase ライセンスをアップロードして、プロフェッショナル/エンタープライズ機能のロックを解除できます。",@@ -3381,6 +3407,7 @@"manage-license": "ライセンスの管理","missing-license-attention": "この機能のロックを解除するには、インスタンスにライセンスを割り当ててください。","n-license-remain": "残り {{n}}",+ "require-license": "インスタンスライセンスが必要です","success-notification": "ライセンスの割り当てが正常に更新されました","used-and-total-license": "割り当てられた/合計インスタンスライセンス","used-and-total-user": "アクティブ/合計ユーザー制限"diff --git a/frontend/src/react/locales/vi-VN.json b/frontend/src/react/locales/vi-VN.jsonindex ea3c20a0a1..b91712f119 100644--- a/frontend/src/react/locales/vi-VN.json+++ b/frontend/src/react/locales/vi-VN.json@@ -196,6 +196,7 @@},"common": {"action-required": "Cần thực hiện hành động",+ "actions": "Hành động","activated": "Đã kích hoạt","active": "Hoạt động","add": "Thêm",@@ -709,6 +710,7 @@"data-size": "Kích thước dữ liệu","edit-environment": "Chỉnh sửa Môi trường","edit-labels": "Chỉnh sửa nhãn",+ "edit-schema": "Chỉnh sửa lược đồ","engine": "Engine","expression": "Expression","filter-database": "Lọc cơ sở dữ liệu",@@ -1304,13 +1306,15 @@"description": "Lọc theo cơ sở dữ liệu"},"engine": {- "description": "Lọc theo engine"+ "description": "Lọc theo engine",+ "title": "Engine"},"environment": {"description": "Lọc theo môi trường"},"instance": {- "description": "Lọc theo phiên bản"+ "description": "Lọc theo phiên bản",+ "title": "Phiên bản"},"issue-label": {"description": "Lọc theo nhãn vấn đề",@@ -2533,10 +2537,19 @@"allow-admin-mode-only": "Phiên bản <instance></instance> chỉ có thể truy cập ở chế độ quản trị.","and-n-more-databases": "and {{n}} more databases","batch-query": {- "batch": "Hàng loạt"+ "batch": "Hàng loạt",+ "description": "Truy vấn hàng loạt {{database}} cơ sở dữ liệu bổ sung và {{group}} nhóm cơ sở dữ liệu trong {{project}}.",+ "select-data-source": {+ "admin": "Quản trị viên",+ "readonly": "Chỉ đọc",+ "self": "Chọn nguồn dữ liệu cho lô",+ "tooltip": "Sẽ tìm các nguồn dữ liệu có sẵn với chính sách hạn chế, sau đó áp dụng lựa chọn."+ }},"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 \"/\".",+ "close-sheet": "Đóng trang tính",+ "connect-in-admin-mode": "Kết nối ở chế độ quản trị","connect-to-a-database": "Kết nối cơ sở dữ liệu","ddl-dml-requires-data-change-plan": "Để thực thi câu lệnh DDL/DML trong <environment></environment>, vui lòng gửi Kế hoạch Thay đổi Dữ liệu để được phê duyệt.","duration-day": "{{days}} day",@@ -2549,15 +2562,20 @@"grant-type-unmask": "Unmask","hint-tips": {"confirm-to-close-unsaved-sheet": {- "content": "Đóng trang tính và mất bất kỳ dữ liệu chưa lưu nào?"+ "content": "Đóng trang tính và mất bất kỳ dữ liệu chưa lưu nào?",+ "title": "Đóng trang tính chưa lưu?"}},"jit": "Just-In-Time Access","link-access": "Truy cập liên kết",+ "loading-databases": "Đang tải Cơ sở dữ liệu...",+ "manage-connections": "Quản lý kết nối","no-access-requests": "No access requests","no-database-selected": "Chưa chọn cơ sở dữ liệu","no-history-found": "Không tìm thấy lịch sử",+ "no-queriable-database": "Không có cơ sở dữ liệu có thể truy vấn","only-select-allowed": "Chỉ cho phép thực thi câu lệnh chỉ đọc.",+ "open-in-new-tab": "Mở trong tab mới","private": "Riêng tư","private-desc": "Chỉ bạn mới có thể truy cập trang tính này","project-read": "Đọc dự án",@@ -2588,11 +2606,17 @@"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",+ "show-databases-without-query-permission": "Hiển thị cơ sở dữ liệu không có quyền truy vấn","tab": {"context-menu": {"actions": {"add-folder": "Thêm thư mục","add-worksheet": "Thêm bảng tính",+ "close": "Đóng",+ "close-all": "Đóng tất cả",+ "close-others": "Đóng các trang tính khác",+ "close-saved": "Đóng các trang tính đã lưu",+ "close-to-the-right": "Đóng các trang tính bên phải","multi-select": "Chọn nhiều","rename": "Đổi tên"}@@ -2600,6 +2624,7 @@},"unmask-warning": "The query result may include unmasked sensitive data.","url-copied-to-clipboard": "URL đã được sao chép vào bảng nhớ tạm của bạn",+ "view-database-detail": "Xem chi tiết cơ sở dữ liệu","view-issue": "View Issue","web-socket": {"errors": {@@ -3367,6 +3392,7 @@"title": "Đánh giá SQL"},"subscription": {+ "contact-to-upgrade": "Liên hệ với quản trị viên Không gian làm việc của bạn để nâng cấp gói.","contact-us": "Liên hệ chúng tôi","current": "Gói hiện tại","description": "Bạn có thể tải lên giấy phép Bytebase của mình để mở khóa các tính năng chuyên nghiệp/doanh nghiệp.",@@ -3381,6 +3407,7 @@"manage-license": "Quản lý giấy phép phiên bản","missing-license-attention": "Bạn cần gán giấy phép cho phiên bản để bật tính năng này.","n-license-remain": "còn lại {{n}}",+ "require-license": "Yêu cầu giấy phép phiên bản","success-notification": "Đã cập nhật thành công gán giấy phép","used-and-total-license": "Giấy phép phiên bản đã gán / Tổng số","used-and-total-user": "Giới hạn người dùng đang hoạt động / Tổng số"diff --git a/frontend/src/react/locales/zh-CN.json b/frontend/src/react/locales/zh-CN.jsonindex c891b0311e..ed1d9a148b 100644--- a/frontend/src/react/locales/zh-CN.json+++ b/frontend/src/react/locales/zh-CN.json@@ -196,6 +196,7 @@},"common": {"action-required": "需要操作",+ "actions": "操作","activated": "已激活","active": "开启","add": "添加",@@ -709,6 +710,7 @@"data-size": "数据大小","edit-environment": "编辑环境","edit-labels": "编辑标签",+ "edit-schema": "变更 Schema","engine": "引擎","expression": "Expression","filter-database": "筛选数据库",@@ -1304,13 +1306,15 @@"description": "按数据库筛选"},"engine": {- "description": "按引擎过滤"+ "description": "按引擎过滤",+ "title": "引擎"},"environment": {"description": "根据环境过滤"},"instance": {- "description": "根据实例过滤"+ "description": "根据实例过滤",+ "title": "实例"},"issue-label": {"description": "按工单标签过滤",@@ -2533,10 +2537,19 @@"allow-admin-mode-only": "实例<instance></instance>只能通过管理员模式访问。","and-n-more-databases": "及其他 {{n}} 个数据库","batch-query": {- "batch": "批量"+ "batch": "批量",+ "description": "批量查询 {{project}} 下的 {{database}} 个数据库和 {{group}} 个数据库组。",+ "select-data-source": {+ "admin": "主数据源",+ "readonly": "只读数据源",+ "self": "选择批量查询使用的数据源",+ "tooltip": "将先根据限制策略寻找数据源,然后应用该选择。"+ }},"choose-folder": "选择或创建文件夹","choose-folder-tips": "您可以通过输入不存在的路径来创建新文件夹。文件夹之间应以\"/\"连接。",+ "close-sheet": "关闭工作表",+ "connect-in-admin-mode": "以管理员模式连接","connect-to-a-database": "连接数据库","ddl-dml-requires-data-change-plan": "如需在 <environment></environment> 中执行 DDL/DML 语句,请创建变更计划以获得审批。","duration-day": "{{days}} 天",@@ -2549,15 +2562,20 @@"grant-type-unmask": "脱敏豁免","hint-tips": {"confirm-to-close-unsaved-sheet": {- "content": "关闭当前工作表会丢失所有未保存的数据?"+ "content": "关闭当前工作表会丢失所有未保存的数据?",+ "title": "确定关闭未保存的工作表?"}},"jit": "即时访问","link-access": "链接访问权限",+ "loading-databases": "加载数据库信息...",+ "manage-connections": "管理连接","no-access-requests": "暂无访问请求","no-database-selected": "未选择数据库","no-history-found": "暂无历史记录",+ "no-queriable-database": "没有可查询的数据库","only-select-allowed": "只允许执行只读语句",+ "open-in-new-tab": "在新选项卡中打开","private": "私有","private-desc": "只有您自己可以访问此工作表","project-read": "项目内可读",@@ -2588,11 +2606,17 @@"search-history-by-statement": "搜索 SQL 语句","select-a-database-to-start": "选择数据库以开始","self": "SQL 编辑器",+ "show-databases-without-query-permission": "显示没有查询权限的数据库","tab": {"context-menu": {"actions": {"add-folder": "添加文件夹","add-worksheet": "添加工作表",+ "close": "关闭",+ "close-all": "关闭所有",+ "close-others": "关闭其他",+ "close-saved": "关闭已保存的",+ "close-to-the-right": "关闭右侧所有的","multi-select": "多选","rename": "重命名"}@@ -2600,6 +2624,7 @@},"unmask-warning": "The query result may include unmasked sensitive data.","url-copied-to-clipboard": "URL 已复制到剪贴板",+ "view-database-detail": "查看数据库详情","view-issue": "查看工单","web-socket": {"errors": {@@ -3367,6 +3392,7 @@"title": "SQL 审核策略"},"subscription": {+ "contact-to-upgrade": "请联系工作空间所有者来升级到试用版。","contact-us": "联系我们","current": "当前版本","description": "您可以在这里上传您购买的 Bytebase 证书来解锁专业版/企业版功能。",@@ -3381,6 +3407,7 @@"manage-license": "管理证书","missing-license-attention": "请给实例分配证书以解锁该功能。","n-license-remain": "剩余 {{n}} 个",+ "require-license": "需要实例证书","success-notification": "证书分配更新成功","used-and-total-license": "已分配 / 总实例证书","used-and-total-user": "活跃/总用户限制"diff --git a/frontend/src/react/pages/project/ProjectDatabaseGroupsPage.tsx b/frontend/src/react/pages/project/ProjectDatabaseGroupsPage.tsxindex 0cb536cf8c..026cef48b8 100644--- a/frontend/src/react/pages/project/ProjectDatabaseGroupsPage.tsx+++ b/frontend/src/react/pages/project/ProjectDatabaseGroupsPage.tsx@@ -1,6 +1,7 @@-import { EllipsisVertical, Plus } from "lucide-react";+import { Plus } from "lucide-react";import { useCallback, useEffect, useMemo, useState } from "react";import { useTranslation } from "react-i18next";+import { DatabaseGroupTable } from "@/react/components/DatabaseGroupTable";import { FeatureAttention } from "@/react/components/FeatureAttention";import { FeatureBadge } from "@/react/components/FeatureBadge";import { Button } from "@/react/components/ui/button";@@ -9,13 +10,6 @@ import {DialogContent,DialogTitle,} from "@/react/components/ui/dialog";-import {- DropdownMenu,- DropdownMenuContent,- DropdownMenuItem,- DropdownMenuTrigger,-} from "@/react/components/ui/dropdown-menu";-import { Input } from "@/react/components/ui/input";import { useVueState } from "@/react/hooks/useVueState";import { router } from "@/router";import {@@ -44,12 +38,11 @@ export function ProjectDatabaseGroupsPage({const projectName = `${projectNamePrefix}${projectId}`;const project = useVueState(() => projectStore.getProjectByName(projectName));- const [searchText, setSearchText] = useState("");const [dbGroupList, setDbGroupList] = useState<DatabaseGroup[]>([]);const [loading, setLoading] = useState(true);const [deleteTarget, setDeleteTarget] = useState<DatabaseGroup | null>(null);- // Fetch database groups+ // Fetch database groups for this project.useEffect(() => {setLoading(true);setDbGroupList([]);@@ -77,16 +70,6 @@ export function ProjectDatabaseGroupsPage({[project]);- const filteredList = useMemo(() => {- const filter = searchText.trim().toLowerCase();- if (!filter) return dbGroupList;- return dbGroupList.filter(- (group) =>- group.name.toLowerCase().includes(filter) ||- group.title.toLowerCase().includes(filter)- );- }, [dbGroupList, searchText]);-const handleCreate = useCallback(() => {router.push({ name: PROJECT_V1_ROUTE_DATABASE_GROUPS_CREATE });}, []);@@ -115,36 +98,34 @@ export function ProjectDatabaseGroupsPage({}, [deleteTarget, dbGroupStore]);return (- <div className="py-4 flex flex-col">- <div className="px-4 flex flex-col gap-y-2 pb-2">+ <div className="py-4 flex flex-col gap-y-2">+ <div className="px-4 flex flex-col gap-y-2"><FeatureAttention feature={PlanFeature.FEATURE_DATABASE_GROUPS} />- <div className="flex flex-row items-center justify-end gap-x-2">- <Input- className="max-w-full"- placeholder={t("common.filter-by-name")}- value={searchText}- onChange={(e) => setSearchText(e.target.value)}- />- <Button disabled={!canCreate} onClick={handleCreate}>- <FeatureBadge- feature={PlanFeature.FEATURE_DATABASE_GROUPS}- className="text-white"- />- <Plus className="size-4 mr-1" />- {t("common.create")}- </Button>- </div></div>- <DatabaseGroupTable- databaseGroupList={filteredList}- loading={loading}- showActions={canDelete}- onRowClick={handleRowClick}- onDelete={setDeleteTarget}- />+ <div className="px-4">+ <DatabaseGroupTable+ projectName={projectName}+ view={DatabaseGroupView.BASIC}+ externalList={dbGroupList}+ externalLoading={loading}+ showActions={canDelete}+ pageSize={20}+ onRowClick={handleRowClick}+ onDelete={setDeleteTarget}+ trailingAction={+ <Button disabled={!canCreate} onClick={handleCreate}>+ <FeatureBadge+ feature={PlanFeature.FEATURE_DATABASE_GROUPS}+ className="text-white"+ fallback={<Plus className="size-4 mr-1" />}+ />+ {t("common.create")}+ </Button>+ }+ />+ </div>- {/* Delete confirmation dialog */}<Dialogopen={deleteTarget !== null}onOpenChange={(open) => {@@ -154,9 +135,7 @@ export function ProjectDatabaseGroupsPage({<DialogContent><DialogTitle>{deleteTarget- ? t("database-group.delete-group", {- name: deleteTarget.title,- })+ ? t("database-group.delete-group", { name: deleteTarget.title }): ""}</DialogTitle><p className="text-sm text-control-light">@@ -175,149 +154,3 @@ export function ProjectDatabaseGroupsPage({</div>);}--// ----------------------------------------------------------------------------// DatabaseGroupTable-// ----------------------------------------------------------------------------function DatabaseGroupTable({- databaseGroupList,- loading,- showActions,- onRowClick,- onDelete,-}: {- databaseGroupList: DatabaseGroup[];- loading: boolean;- showActions: boolean;- onRowClick: (e: React.MouseEvent, group: DatabaseGroup) => void;- onDelete: (group: DatabaseGroup) => void;-}) {- const { t } = useTranslation();- const PAGE_SIZE = 20;- const [page, setPage] = useState(0);-- // Reset page when list changes- useEffect(() => {- setPage(0);- }, [databaseGroupList.length]);-- const totalPages = Math.ceil(databaseGroupList.length / PAGE_SIZE);- const pagedList = databaseGroupList.slice(- page * PAGE_SIZE,- (page + 1) * PAGE_SIZE- );-- if (loading) {- return (- <div className="flex justify-center py-8 text-control-light">- {t("common.loading")}- </div>- );- }-- if (databaseGroupList.length === 0) {- return (- <div className="flex justify-center py-8 text-control-light">- {t("common.no-data")}- </div>- );- }-- return (- <div className="px-4">- <table className="w-full text-sm">- <thead>- <tr className="border-b text-left text-control-light">- <th className="py-2 pr-4 font-medium w-64">{t("common.name")}</th>- <th className="py-2 pr-4 font-medium">- {t("database.expression")}- </th>- {showActions && <th className="py-2 font-medium w-12" />}- </tr>- </thead>- <tbody>- {pagedList.map((group) => (- <tr- key={group.name}- className="border-b cursor-pointer hover:bg-control-bg"- onClick={(e) => onRowClick(e, group)}- >- <td className="py-2 pr-4 truncate max-w-64">{group.title}</td>- <td className="py-2 pr-4 truncate text-control-light">- {group.databaseExpr?.expression || (- <span className="italic">{t("common.empty")}</span>- )}- </td>- {showActions && (- <td className="py-2">- <ActionDropdown group={group} onDelete={onDelete} />- </td>- )}- </tr>- ))}- </tbody>- </table>-- {totalPages > 1 && (- <div className="flex justify-end items-center gap-x-2 mt-3">- <Button- variant="outline"- size="sm"- disabled={page === 0}- onClick={() => setPage((p) => p - 1)}- >- {t("common.previous")}- </Button>- <span className="text-sm text-control-light">- {page + 1} / {totalPages}- </span>- <Button- variant="outline"- size="sm"- disabled={page >= totalPages - 1}- onClick={() => setPage((p) => p + 1)}- >- {t("common.next")}- </Button>- </div>- )}- </div>- );-}--// ----------------------------------------------------------------------------// ActionDropdown-// ----------------------------------------------------------------------------function ActionDropdown({- group,- onDelete,-}: {- group: DatabaseGroup;- onDelete: (group: DatabaseGroup) => void;-}) {- const { t } = useTranslation();-- return (- <div className="flex justify-end">- <DropdownMenu>- <DropdownMenuTrigger- className="p-1 rounded-xs hover:bg-control-bg outline-hidden"- onClick={(e) => e.stopPropagation()}- >- <EllipsisVertical className="size-4" />- </DropdownMenuTrigger>- <DropdownMenuContent>- <DropdownMenuItem- className="text-error"- onClick={(e) => {- e.stopPropagation();- onDelete(group);- }}- >- {t("common.delete")}- </DropdownMenuItem>- </DropdownMenuContent>- </DropdownMenu>- </div>- );-}diff --git a/frontend/src/react/pages/project/ProjectMaskingExemptionCreatePage.tsx b/frontend/src/react/pages/project/ProjectMaskingExemptionCreatePage.tsxindex 3961e1fa50..a28fd79ece 100644--- a/frontend/src/react/pages/project/ProjectMaskingExemptionCreatePage.tsx+++ b/frontend/src/react/pages/project/ProjectMaskingExemptionCreatePage.tsx@@ -20,12 +20,8 @@ import { ExprEditor } from "@/react/components/ExprEditor";import { FeatureAttention } from "@/react/components/FeatureAttention";import { FeatureBadge } from "@/react/components/FeatureBadge";import { Button } from "@/react/components/ui/button";-import {- Dialog,- DialogContent,- DialogTitle,-} from "@/react/components/ui/dialog";import { ExpirationPicker } from "@/react/components/ui/expiration-picker";+import { FeatureModal } from "@/react/components/ui/feature-modal";import { Input } from "@/react/components/ui/input";import { Tooltip } from "@/react/components/ui/tooltip";import { useVueState } from "@/react/hooks/useVueState";@@ -439,26 +435,13 @@ export function ProjectMaskingExemptionCreatePage({</div></div>- {/* Feature modal */}- <Dialog+ {/* Feature paywall — shared FeatureModal so the dialog content is+ driven by the subscription dynamic feature copy + plan info. */}+ <FeatureModalopen={showFeatureModal}- onOpenChange={(open) => {- if (!open) setShowFeatureModal(false);- }}- >- <DialogContent className="p-6">- <DialogTitle>{t("common.warning")}</DialogTitle>- <FeatureAttention feature={PlanFeature.FEATURE_DATA_MASKING} />- <div className="flex justify-end gap-x-2 mt-4">- <Button- variant="outline"- onClick={() => setShowFeatureModal(false)}- >- {t("common.cancel")}- </Button>- </div>- </DialogContent>- </Dialog>+ feature={PlanFeature.FEATURE_DATA_MASKING}+ onOpenChange={setShowFeatureModal}+ /></div>);}diff --git a/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx b/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsxindex 7022d357ee..b8e9ce80f1 100644--- a/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx+++ b/frontend/src/react/pages/project/ProjectMaskingExemptionPage.tsx@@ -32,6 +32,7 @@ import {DialogContent,DialogTitle,} from "@/react/components/ui/dialog";+import { FeatureModal } from "@/react/components/ui/feature-modal";import { Tabs, TabsList, TabsTrigger } from "@/react/components/ui/tabs";import { useVueState } from "@/react/hooks/useVueState";import { cn } from "@/react/lib/utils";@@ -404,10 +405,10 @@ export function ProjectMaskingExemptionPage({placeholder={t("issue.advanced-search.filter")}/><Button onClick={handleGrantClick} disabled={!hasCreatePermission}>- <ShieldCheck className="size-4" /><FeatureBadgefeature={PlanFeature.FEATURE_DATA_MASKING}className="text-white"+ fallback={<ShieldCheck className="size-4" />}/>{t("project.masking-exemption.grant-exemption")}</Button>@@ -471,26 +472,14 @@ export function ProjectMaskingExemptionPage({/>)}- {/* Feature modal — navigate to subscription page */}- <Dialog+ {/* Feature paywall — uses the shared `FeatureModal` so the title,+ description, plan info, and CTAs come from the subscription+ dynamic content instead of a one-off Dialog. */}+ <FeatureModalopen={showFeatureModal}- onOpenChange={(open) => {- if (!open) setShowFeatureModal(false);- }}- >- <DialogContent className="p-6">- <DialogTitle>{t("common.warning")}</DialogTitle>- <FeatureAttention feature={PlanFeature.FEATURE_DATA_MASKING} />- <div className="flex justify-end gap-x-2 mt-4">- <Button- variant="outline"- onClick={() => setShowFeatureModal(false)}- >- {t("common.cancel")}- </Button>- </div>- </DialogContent>- </Dialog>+ feature={PlanFeature.FEATURE_DATA_MASKING}+ onOpenChange={setShowFeatureModal}+ />{/* Revoke confirmation dialog */}<Dialogdiff --git a/frontend/src/react/pages/project/database-detail/catalog/GrantAccessDialog.test.tsx b/frontend/src/react/pages/project/database-detail/catalog/GrantAccessDialog.test.tsxindex 14a37ead07..49cdea2d11 100644--- a/frontend/src/react/pages/project/database-detail/catalog/GrantAccessDialog.test.tsx+++ b/frontend/src/react/pages/project/database-detail/catalog/GrantAccessDialog.test.tsx@@ -146,6 +146,11 @@ vi.mock("@/react/components/FeatureBadge", () => ({FeatureBadge: () => <div data-testid="feature-badge" />,}));+vi.mock("@/react/components/ui/feature-modal", () => ({+ FeatureModal: ({ open }: { open: boolean }) =>+ open ? <div data-testid="feature-modal" /> : null,+}));+vi.mock("@/react/components/ui/button", () => ({Button: (props: ButtonHTMLAttributes<HTMLButtonElement>) => (<button {...props} />diff --git a/frontend/src/react/pages/project/database-detail/catalog/GrantAccessDialog.tsx b/frontend/src/react/pages/project/database-detail/catalog/GrantAccessDialog.tsxindex f27fb03368..3afab92ed6 100644--- a/frontend/src/react/pages/project/database-detail/catalog/GrantAccessDialog.tsx+++ b/frontend/src/react/pages/project/database-detail/catalog/GrantAccessDialog.tsx@@ -40,6 +40,7 @@ import {DialogTitle,} from "@/react/components/ui/dialog";import { ExpirationPicker } from "@/react/components/ui/expiration-picker";+import { FeatureModal } from "@/react/components/ui/feature-modal";import { Input } from "@/react/components/ui/input";import { Tooltip } from "@/react/components/ui/tooltip";import { useVueState } from "@/react/hooks/useVueState";@@ -685,28 +686,15 @@ export function GrantAccessDialog({</DialogContent></Dialog>- <Dialog+ {/* Feature paywall — shared FeatureModal so the dialog content is+ driven by the subscription dynamic feature copy + plan info, and+ honors the instance-missing-license path via the `instance` prop. */}+ <FeatureModalopen={showFeatureModal}- onOpenChange={(isOpen) => {- if (!isOpen) setShowFeatureModal(false);- }}- >- <DialogContent className="p-6">- <DialogTitle>{t("common.warning")}</DialogTitle>- <FeatureAttention- feature={PlanFeature.FEATURE_DATA_MASKING}- instance={instance}- />- <div className="flex justify-end gap-x-2 mt-4">- <Button- variant="outline"- onClick={() => setShowFeatureModal(false)}- >- {t("common.cancel")}- </Button>- </div>- </DialogContent>- </Dialog>+ feature={PlanFeature.FEATURE_DATA_MASKING}+ instance={instance}+ onOpenChange={setShowFeatureModal}+ /></>);}diff --git a/frontend/src/react/pages/settings/GroupsPage.tsx b/frontend/src/react/pages/settings/GroupsPage.tsxindex 9a8b548cca..e5ccef946d 100644--- a/frontend/src/react/pages/settings/GroupsPage.tsx+++ b/frontend/src/react/pages/settings/GroupsPage.tsx@@ -1066,10 +1066,10 @@ export function GroupsPage() {}><Button disabled>- <Plus className="h-4 w-4 mr-1" /><FeatureBadgefeature={PlanFeature.FEATURE_USER_GROUPS}clickable={false}+ fallback={<Plus className="h-4 w-4 mr-1" />}/>{t("common.create")}</Button>@@ -1085,10 +1085,10 @@ export function GroupsPage() {setShowCreateGroupDrawer(true);}}>- <Plus className="h-4 w-4 mr-1" /><FeatureBadgefeature={PlanFeature.FEATURE_USER_GROUPS}clickable={false}+ fallback={<Plus className="h-4 w-4 mr-1" />}/>{t("common.create")}</Button>diff --git a/frontend/src/react/pages/settings/IDPsPage.tsx b/frontend/src/react/pages/settings/IDPsPage.tsxindex 86cc745163..1c957be156 100644--- a/frontend/src/react/pages/settings/IDPsPage.tsx+++ b/frontend/src/react/pages/settings/IDPsPage.tsx@@ -2036,8 +2036,8 @@ export function IDPsPage() {feature={PlanFeature.FEATURE_GOOGLE_AND_GITHUB_SSO}clickable={false}className="mr-1 text-white inline-flex"+ fallback={<Plus className="h-4 w-4 mr-1" />}/>- <Plus className="h-4 w-4 mr-1" />{t("common.create")}</Button></PermissionGuard>diff --git a/frontend/src/react/pages/settings/RolesPage.tsx b/frontend/src/react/pages/settings/RolesPage.tsxindex 0861af3fb0..a6de8f8d2f 100644--- a/frontend/src/react/pages/settings/RolesPage.tsx+++ b/frontend/src/react/pages/settings/RolesPage.tsx@@ -790,8 +790,8 @@ export function RolesPage() {feature={PlanFeature.FEATURE_CUSTOM_ROLES}clickable={false}className="mr-1 text-white inline-flex"+ fallback={<Plus className="h-4 w-4 mr-1" />}/>- <Plus className="h-4 w-4 mr-1" />{t("common.create")}</Button></PermissionGuard>diff --git a/frontend/src/react/pages/settings/profile/ProfilePage.tsx b/frontend/src/react/pages/settings/profile/ProfilePage.tsxindex 585f967936..8c07dddb80 100644--- a/frontend/src/react/pages/settings/profile/ProfilePage.tsx+++ b/frontend/src/react/pages/settings/profile/ProfilePage.tsx@@ -15,6 +15,7 @@ import {DialogDescription,DialogTitle,} from "@/react/components/ui/dialog";+import { FeatureModal } from "@/react/components/ui/feature-modal";import { Input } from "@/react/components/ui/input";import { useClickOutside } from "@/react/hooks/useClickOutside";import { useVueState } from "@/react/hooks/useVueState";@@ -642,35 +643,14 @@ export function ProfilePage({ principalEmail }: ProfilePageProps) {)}</div>- {/* Feature modal for 2FA */}- <Dialog open={showFeatureModal} onOpenChange={setShowFeatureModal}>- <DialogContent className="p-6">- <DialogTitle>{t("subscription.disabled-feature")}</DialogTitle>- <DialogDescription className="mt-2">- {t("subscription.require-subscription", {- requiredPlan: t("subscription.plan.enterprise.title"),- })}- </DialogDescription>- <div className="mt-4 flex justify-end gap-x-2">- <Button- variant="outline"- onClick={() => setShowFeatureModal(false)}- >- {t("common.cancel")}- </Button>- <Button- onClick={() => {- setShowFeatureModal(false);- router.push({- name: SETTING_ROUTE_WORKSPACE_SUBSCRIPTION,- });- }}- >- {t("common.learn-more")}- </Button>- </div>- </DialogContent>- </Dialog>+ {/* 2FA paywall — uses the shared `FeatureModal` so copy stays in+ sync with subscription dynamic content (title, description,+ required-plan / trial line) instead of a hand-written Dialog. */}+ <FeatureModal+ open={showFeatureModal}+ feature={PlanFeature.FEATURE_TWO_FA}+ onOpenChange={setShowFeatureModal}+ />{/* Disable 2FA confirm dialog */}<Dialogdiff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/ConnectionPane.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/ConnectionPane.vuedeleted file mode 100644index 63dfdda019..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/ConnectionPane.vue+++ /dev/null@@ -1,853 +0,0 @@-<template>- <div class="sql-editor-tree h-full relative">- <div class="w-full px-4 mt-4" v-if="tabStore.supportBatchMode">- <div- class="textinfolabel mb-2 w-full leading-4 flex flex-col items-start gap-x-1"- >- <div class="flex items-center gap-x-1">- <FeatureBadge :feature="PlanFeature.FEATURE_BATCH_QUERY" />- {{- $t("sql-editor.batch-query.description", {- database: selectedDatabaseNames.length,- group:- tabStore.currentTab?.batchQueryContext.databaseGroups- ?.length ?? 0,- project: project.title,- })- }}- </div>- </div>- <div- class="w-full mt-1 flex flex-row justify-start items-start flex-wrap gap-2"- >- <NTag- v-for="database in selectedDatabaseNames"- :key="database"- :closable="true"- :disabled="state.switchingConnection"- @close="() => handleToggleDatabase(database, false)"- >- <RichDatabaseName- :database="databaseStore.getDatabaseByName(database)"- />- </NTag>- <template v-if="hasDatabaseGroupFeature">- <DatabaseGroupTag- v-for="databaseGroupName in tabStore.currentTab?.batchQueryContext- ?.databaseGroups ?? []"- :key="databaseGroupName"- :disabled="state.switchingConnection"- :database-group-name="databaseGroupName"- @uncheck="handleUncheckDatabaseGroup"- />- </template>- <NDivider v-if="tabStore.isInBatchMode" class="my-2!" />- <div v-if="tabStore.isInBatchMode" class="w-full">- <div class="textinfolabel flex items-center gap-x-1">- {{ $t("sql-editor.batch-query.select-data-source.self") }}- <NTooltip>- <template #trigger>- <InfoIcon class="w-4" />- </template>- {{ $t("sql-editor.batch-query.select-data-source.tooltip") }}- </NTooltip>- </div>- <NRadioGroup v-model:value="state.batchQueryDataSourceType">- <NRadio :value="DataSourceType.ADMIN">- {{ getDataSourceTypeI18n(DataSourceType.ADMIN) }}- </NRadio>- <NRadio :value="DataSourceType.READ_ONLY">- {{ getDataSourceTypeI18n(DataSourceType.READ_ONLY) }}- </NRadio>- </NRadioGroup>- </div>- </div>- </div>- <NDivider v-if="tabStore.currentTab" class="my-3!" />- <NTabs- v-model:value="state.selectionMode"- type="line"- animated- size="small"- class="px-4"- >- <NTabPane name="DATABASE" :tab="$t('common.databases')">- <div class="flex flex-col gap-y-1">- <AdvancedSearch- v-model:params="state.params"- :autofocus="false"- :placeholder="$t('database.filter-database')"- :scope-options="scopeOptions"- :cache-query="false"- />- <div- ref="treeContainerElRef"- class="relative sql-editor-tree--tree flex-1 pb-1 text-sm select-none"- :data-height="treeContainerHeight"- >- <template v-if="treeStore.state === 'READY'">- <NCheckbox- v-model:checked="showMissingQueryDatabases"- >- {{ $t("sql-editor.show-databases-without-query-permission") }}- </NCheckbox>- <div- v-for="[environment, treeState] of treeByEnvironment.entries()"- :key="environment"- >- <div- v-if="environment !== UNKNOWN_ENVIRONMENT_NAME || !treeIsEmpty(treeState)"- class="flex flex-col gap-y-2 pt-2 pb-2"- >- <NTree- :block-line="true"- :data="treeState.tree.value"- :show-irrelevant-nodes="false"- :selected-keys="selectedKeys"- :expand-on-click="true"- v-model:expanded-keys="treeState.expandedState.value.expandedKeys"- :node-props="nodeProps"- :theme-overrides="{ nodeHeight: '21px' }"- :render-label="renderLabel"- />- <div- v-if="- !!treeState.fetchDataState.value.nextPageToken &&- treeState.expandedState.value.expandedKeys.includes(- environment- ) &&- (!treeIsEmpty(treeState) ||- showMissingQueryDatabases)- "- class="w-full flex items-center justify-start pl-4"- >- <NButton- quaternary- :size="'small'"- :loading="treeState.fetchDataState.value.loading"- @click="- () =>- treeState- .fetchDatabases(filter)- .then(() => treeState.buildTree(showMissingQueryDatabases))- "- >- {{ $t("common.load-more") }}- </NButton>- </div>- </div>- </div>- </template>- </div>- </div>- </NTabPane>- <NTabPane name="DATABASE-GROUP" :tab="$t('common.database-group')" :disabled="!hasDatabaseGroupFeature || !hasBatchQueryFeature">- <template #tab>- <NTooltip :disabled="hasBatchQueryFeature && hasDatabaseGroupFeature">- <template #trigger>- {{ $t('common.database-group') }}- </template>- {{ $t("subscription.contact-to-upgrade") }}- </NTooltip>- </template>- <DatabaseGroupTable- :database-group-names="selectedDatabaseGroupNames"- @select="handleSelectDatabaseGroup"- @update:database-group-names="onDatabaseGroupSelectionUpdate"- />- </NTabPane>- </NTabs>-- <NDropdown- v-if="treeStore.state === 'READY'"- placement="bottom-start"- trigger="manual"- :x="dropdownPosition.x"- :y="dropdownPosition.y"- :options="dropdownOptions"- :show="showDropdown"- :on-clickoutside="handleDropdownClickoutside"- @select="handleDropdownSelect"- />-- <DatabaseHoverPanel :offset-x="10" :offset-y="4" :margin="4" />-- <MaskSpinner v-if="treeStore.state !== 'READY'" class="bg-white/75!">- <span class="text-control text-sm">{{- $t("sql-editor.loading-databases")- }}</span>- </MaskSpinner>- </div>-- <FeatureModal- v-if="state.missingFeature"- :feature="state.missingFeature"- :open="!!state.missingFeature"- @cancel="state.missingFeature = undefined"- />-</template>--<script lang="ts" setup>-import { useElementSize } from "@vueuse/core";-import { cloneDeep } from "lodash-es";-import { InfoIcon } from "lucide-vue-next";-import {- NButton,- NCheckbox,- NDivider,- NDropdown,- NRadio,- NRadioGroup,- NTabPane,- NTabs,- NTag,- NTooltip,- NTree,- type TreeOption,-} from "naive-ui";-import { computed, h, nextTick, reactive, ref, shallowRef, watch } from "vue";-import { useI18n } from "vue-i18n";-import AdvancedSearch from "@/components/AdvancedSearch";-import { useCommonSearchScopeOptions } from "@/components/AdvancedSearch/useCommonSearchScopeOptions";-import { FeatureBadge, FeatureModal } from "@/components/FeatureGuard";-import MaskSpinner from "@/components/misc/MaskSpinner.vue";-import { RichDatabaseName } from "@/components/v2";-import { useEmitteryEventListener } from "@/composables/useEmitteryEventListener";-import {- type DatabaseFilter,- featureToRef,- idForSQLEditorTreeNodeTarget,- pushNotification,- useCurrentUserV1,- useDatabaseV1Store,- useDBGroupStore,- useEnvironmentV1Store,- useInstanceResourceByName,- useProjectV1Store,- useSQLEditorStore,- useSQLEditorTabStore,- useSQLEditorTreeStore,-} from "@/store";-import { instanceNamePrefix } from "@/store/modules/v1/common";-import type {- BatchQueryContext,- QueryDataSourceType,- SQLEditorTreeNode,-} from "@/types";-import {- getDataSourceTypeI18n,- isValidDatabaseGroupName,- isValidDatabaseName,- isValidProjectName,- UNKNOWN_ENVIRONMENT_NAME,- unknownEnvironment,-} from "@/types";-import { Engine } from "@/types/proto-es/v1/common_pb";-import type { Database } from "@/types/proto-es/v1/database_service_pb";-import { DataSourceType } from "@/types/proto-es/v1/instance_service_pb";-import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";-import type { SearchParams } from "@/utils";-import {- CommonFilterScopeIdList,- extractProjectResourceName,- findAncestor,- getConnectionForSQLEditorTab,- getValueFromSearchParams,- getValuesFromSearchParams,- storageKeySqlEditorShowMissingQueryDb,- useDynamicLocalStorage,-} from "@/utils";-import { useSQLEditorContext } from "../../context";-import { setConnection, useDropdown } from "./actions";-import DatabaseGroupTable from "./DatabaseGroupTable.vue";-import DatabaseGroupTag from "./DatabaseGroupTag.vue";-import {- DatabaseHoverPanel,- provideHoverStateContext,-} from "./DatabaseHoverPanel";-import { Label } from "./TreeNode";-import { type TreeByEnvironment, useSQLEditorTreeByEnvironment } from "./tree";--interface LocalState {- params: SearchParams;- missingFeature?: PlanFeature;- batchQueryDataSourceType?: QueryDataSourceType;- selectionMode: "DATABASE" | "DATABASE-GROUP";- switchingConnection: boolean;-}--const props = defineProps<{- show: boolean;-}>();--const treeStore = useSQLEditorTreeStore();-const tabStore = useSQLEditorTabStore();-const editorStore = useSQLEditorStore();-const databaseStore = useDatabaseV1Store();-const dbGroupStore = useDBGroupStore();-const projectStore = useProjectV1Store();-const currentUser = useCurrentUserV1();-const { t } = useI18n();--const environmentList = computed(() => useEnvironmentV1Store().environmentList);--const showMissingQueryDatabases = useDynamicLocalStorage<boolean>(- computed(() =>- storageKeySqlEditorShowMissingQueryDb(currentUser.value.email)- ),- true-);--watch(- () => showMissingQueryDatabases.value,- (showMissingQueryDatabases) => {- for (const treeState of treeByEnvironment.value.values()) {- treeState.buildTree(showMissingQueryDatabases);- }- }-);--const hasBatchQueryFeature = featureToRef(PlanFeature.FEATURE_BATCH_QUERY);-const hasDatabaseGroupFeature = featureToRef(- PlanFeature.FEATURE_DATABASE_GROUPS-);--const state = reactive<LocalState>({- params: {- query: "",- scopes: [],- },- batchQueryDataSourceType: DataSourceType.READ_ONLY,- selectionMode: "DATABASE",- switchingConnection: false,-});--const selectedDatabaseGroupNames = computed(- () => tabStore.currentTab?.batchQueryContext.databaseGroups ?? []-);--const selectedDatabaseNames = computed(() => {- const currentTab = tabStore.currentTab;- const databases = currentTab?.batchQueryContext.databases ?? [];- if (databases.length === 0 && selectedDatabaseGroupNames.value.length === 0) {- if (currentTab?.connection.database) {- databases.push(currentTab?.connection.database);- }- }- return databases;-});--watch(- () => props.show,- (show) => {- if (show) {- if (selectedDatabaseNames.value.length > 0) {- state.selectionMode = "DATABASE";- } else if (selectedDatabaseGroupNames.value.length > 0) {- state.selectionMode = "DATABASE-GROUP";- } else {- state.selectionMode = "DATABASE";- }- }- },- { immediate: true }-);--// onBatchQueryContextChange changes the batchQueryContext and connect to the 1st queryable database.-// return boolean true if exists any queryable database in the batchQueryContext.-const onBatchQueryContextChange = async (- batchQueryContext: BatchQueryContext-): Promise<boolean> => {- state.switchingConnection = true;-- try {- const queryableDatabase = await getQueryableDatabase(batchQueryContext);- const currentConnection = getConnectionForSQLEditorTab(tabStore.currentTab);-- if (- !currentConnection.database?.name ||- currentConnection.database?.name !== queryableDatabase?.name- ) {- // switch connection when:- // - no connection- // - no current tab- // - current tab doesn't have valid connection- // - or connection changed- setConnection({- database: queryableDatabase,- mode: "WORKSHEET",- newTab: false,- context: editorContext,- batchQueryContext,- });- } else {- tabStore.updateBatchQueryContext(batchQueryContext);- }- return !!queryableDatabase;- } finally {- state.switchingConnection = false;- }-};--const getQueryableDatabase = async (batchQueryContext: BatchQueryContext) => {- if (batchQueryContext.databases.length > 0) {- return databaseStore.getDatabaseByName(batchQueryContext.databases[0]);- }-- for (const databaseGroupName of batchQueryContext.databaseGroups ?? []) {- const databaseGroup = dbGroupStore.getDBGroupByName(databaseGroupName);- const databases = await databaseStore.batchGetOrFetchDatabases(- databaseGroup.matchedDatabases.map((db) => db.name)- );- if (databases.length > 0) {- return databases[0];- }- }-};--const onDatabaseSelectionUpdate = async (databases: string[]) => {- const batchQueryContext: BatchQueryContext = cloneDeep({- ...tabStore.currentTab?.batchQueryContext,- databases,- });- await onBatchQueryContextChange(batchQueryContext);-};--const onDatabaseGroupSelectionUpdate = async (databaseGroups: string[]) => {- if (databaseGroups.length > 0) {- if (!hasBatchQueryFeature) {- state.missingFeature = PlanFeature.FEATURE_BATCH_QUERY;- return;- }- if (!hasDatabaseGroupFeature) {- state.missingFeature = PlanFeature.FEATURE_DATABASE_GROUPS;- return;- }- }-- const batchQueryContext: BatchQueryContext = cloneDeep({- ...(tabStore.currentTab?.batchQueryContext ?? { databases: [] }),- databaseGroups,- });- const success = await onBatchQueryContextChange(batchQueryContext);-- if (databaseGroups.length > 0 && !success) {- pushNotification({- module: "bytebase",- style: "CRITICAL",- title: t("sql-editor.no-queriable-database"),- });- }-};--const handleSelectDatabaseGroup = async (name: string) => {- const batchQueryContext: BatchQueryContext = cloneDeep({- ...(tabStore.currentTab?.batchQueryContext ?? { databases: [] }),- databaseGroups: [name],- });- const success = await onBatchQueryContextChange(batchQueryContext);- if (success) {- showConnectionPanel.value = false;- } else {- pushNotification({- module: "bytebase",- style: "CRITICAL",- title: t("sql-editor.no-queriable-database"),- });- }-};--const flattenSelectedDatabasesFromGroup = computed(() => {- const nameMap = new Map<- string /* database name */,- string /* group title */- >();- for (const groupName of tabStore.currentTab?.batchQueryContext- ?.databaseGroups ?? []) {- const group = dbGroupStore.getDBGroupByName(groupName);- if (!isValidDatabaseGroupName(group.name)) {- continue;- }- for (const db of group.matchedDatabases) {- nameMap.set(db.name, group.title);- }- }- return nameMap;-});--const treeByEnvironment = shallowRef<- Map<string /* environment full name */, TreeByEnvironment>->(new Map());--const treeIsEmpty = (value: TreeByEnvironment) => {- if (value.tree.value.length === 0) {- return true;- }- const children = value.tree.value[0].children;- if (!children || children.length === 0) {- return true;- }- return false;-};--watch(- () => state.batchQueryDataSourceType,- (dataSourceType) => {- tabStore.updateBatchQueryContext({- dataSourceType,- });- },- { immediate: true }-);--watch(- () => tabStore.currentTab?.id,- async () => {- if (!tabStore.currentTab) {- return;- }- const databases = tabStore.currentTab.batchQueryContext.databases ?? [];- await databaseStore.batchGetOrFetchDatabases(databases);- },- {- immediate: true,- }-);--const handleToggleDatabase = async (database: string, check: boolean) => {- let databases: string[] = [...selectedDatabaseNames.value];- if (check) {- if (!databases.includes(database)) {- databases.push(database);- }- if (databases.length > 1 && !hasBatchQueryFeature.value) {- state.missingFeature = PlanFeature.FEATURE_BATCH_QUERY;- return;- }- } else {- databases = selectedDatabaseNames.value.filter((db) => db !== database);- }- await onDatabaseSelectionUpdate(databases);-};--const handleUncheckDatabaseGroup = async (databaseGroupName: string) => {- const databaseGroups = selectedDatabaseGroupNames.value.filter(- (name) => name !== databaseGroupName- );- await onDatabaseGroupSelectionUpdate(databaseGroups);-};--const scopeOptions = useCommonSearchScopeOptions([- ...CommonFilterScopeIdList.filter((scope) => scope !== "environment"),- "label",- "engine",-]);--const project = computed(() =>- projectStore.getProjectByName(editorStore.project)-);--const editorContext = useSQLEditorContext();-const { events: editorEvents, showConnectionPanel } = editorContext;-const {- state: hoverState,- position: hoverPosition,- update: updateHoverNode,-} = provideHoverStateContext();-const {- show: showDropdown,- context: dropdownContext,- position: dropdownPosition,- options: dropdownOptions,- handleSelect: handleDropdownSelect,- handleClickoutside: handleDropdownClickoutside,-} = useDropdown();--const treeContainerElRef = ref<HTMLElement>();-const { height: treeContainerHeight } = useElementSize(- treeContainerElRef,- undefined,- {- box: "content-box",- }-);-const selectedKeys = ref<string[]>([]);--// Highlight the current tab's connection node.-const getSelectedKeys = async () => {- const connection = tabStore.currentTab?.connection;- if (!connection) {- return [];- }-- if (connection.database) {- const database = await databaseStore.getOrFetchDatabaseByName(- connection.database- );- return treeStore.nodeKeysByTarget("database", database);- } else if (connection.instance) {- const { instance } = useInstanceResourceByName(connection.instance);- return treeStore.nodeKeysByTarget("instance", instance.value);- }- return [];-};--// The connection panel should:-// - change the connection for the current tab-// - connect to a new tab, this will create a new worksheet-const connect = (node: SQLEditorTreeNode) => {- if (node.disabled || node.meta.type !== "database") {- return;- }- const database = node.meta.target as Database;-- const batchQueryDatabases = [- ...selectedDatabaseGroupNames.value,- database.name,- ].filter(isValidDatabaseName);- setConnection({- database,- mode: tabStore.currentTab?.mode,- newTab: false,- context: editorContext,- batchQueryContext: {- databases: [...new Set(batchQueryDatabases)],- },- });- showConnectionPanel.value = false;-};--// dynamic render the highlight keywords-const renderLabel = ({ option }: { option: TreeOption }) => {- const node = option as SQLEditorTreeNode;- let databaseName = "";- if (node.meta.type === "database") {- databaseName = (node as SQLEditorTreeNode<"database">).meta.target.name;- }-- const checkedByGroup =- flattenSelectedDatabasesFromGroup.value.get(databaseName);- let checkTooltip = "";- if (!!checkedByGroup) {- checkTooltip = t("sql-editor.matched-in-group", { title: checkedByGroup });- } else if (tabStore.currentTab?.connection.database === databaseName) {- checkTooltip = t("sql-editor.current-connection");- }-- return h(Label, {- node,- checked:- selectedDatabaseNames.value.includes(databaseName) || !!checkedByGroup,- checkDisabled: !!checkedByGroup || state.switchingConnection,- checkTooltip,- keyword: state.params.query,- onClick: () => {- if (node.disabled) {- return;- }- if (node.meta.type === "database") {- connect(node);- }- },- "onUpdate:checked": (checked: boolean) => {- if (node.meta.type !== "database") {- return;- }- if (checked) {- handleToggleDatabase(databaseName, true);- } else {- handleToggleDatabase(databaseName, false);- }- },- });-};--const nodeProps = ({ option }: { option: TreeOption }) => {- const node = option as SQLEditorTreeNode;- return {- onContextmenu(e: MouseEvent) {- e.preventDefault();- showDropdown.value = false;- if (node && node.key) {- dropdownContext.value = node;- }-- nextTick().then(() => {- showDropdown.value = true;- dropdownPosition.value.x = e.clientX;- dropdownPosition.value.y = e.clientY;- });- },- onmouseenter(e: MouseEvent) {- if (node.meta.type === "database") {- if (hoverState.value) {- updateHoverNode({ node }, "before", 0 /* overrideDelay */);- } else {- updateHoverNode({ node }, "before");- }- nextTick().then(() => {- // Find the node element and put the database panel to the right corner- // of the node- const wrapper = findAncestor(e.target as HTMLElement, ".n-tree-node");- if (!wrapper) {- updateHoverNode(undefined, "after", 0 /* overrideDelay */);- return;- }- const bounding = wrapper.getBoundingClientRect();- hoverPosition.value.x = bounding.left;- hoverPosition.value.y = bounding.bottom;- });- }- },- onmouseleave() {- updateHoverNode(undefined, "after");- },- // attrs below for trouble-shooting- "data-node-meta-type": node.meta.type,- "data-node-meta-id": idForSQLEditorTreeNodeTarget(- node.meta.type,- node.meta.target- ),- "data-node-key": node.key,- };-};--useEmitteryEventListener(editorEvents, "tree-ready", async () => {- selectedKeys.value = await getSelectedKeys();-- for (const [environment, treeState] of treeByEnvironment.value.entries()) {- if (!treeState.expandedState.value.initialized) {- // default expand all nodes.- treeState.expandedState.value.expandedKeys = treeStore.allNodeKeys.filter(- (key) => key.startsWith(environment)- );- }- }-});--const selectedLabels = computed(() => {- return getValuesFromSearchParams(state.params, "label");-});--const selectedInstance = computed(() => {- return getValueFromSearchParams(state.params, "instance", instanceNamePrefix);-});--const selectedEngines = computed(() => {- return getValuesFromSearchParams(state.params, "engine").map(- (engine) => Engine[engine as keyof typeof Engine]- );-});--const filter = computed(- (): DatabaseFilter => ({- instance: selectedInstance.value,- query: state.params.query,- labels: selectedLabels.value,- engines: selectedEngines.value,- })-);--watch(- () => editorStore.project,- (project) => {- state.params.scopes = [- {- id: "project",- readonly: true,- value: extractProjectResourceName(project),- },- ];- },- { immediate: true }-);--const prepareDatabases = async () => {- treeByEnvironment.value.clear();- await Promise.all(- [...environmentList.value, unknownEnvironment()].map(- async (environment) => {- if (!treeByEnvironment.value.has(environment.name)) {- treeByEnvironment.value.set(- environment.name,- useSQLEditorTreeByEnvironment(environment.name)- );- }- await treeByEnvironment.value- .get(environment.name)- ?.prepareDatabases(filter.value);- treeByEnvironment.value- .get(environment.name)- ?.buildTree(showMissingQueryDatabases.value);- }- )- );-};--watch(- [- () => editorStore.project,- () => editorStore.projectContextReady,- () => filter.value,- ],- async ([project, ready, _]) => {- if (!isValidProjectName(project)) {- return;- }- if (!ready) {- treeStore.state = "LOADING";- } else {- await prepareDatabases();- treeStore.state = "READY";- editorEvents.emit("tree-ready");- }- },- { immediate: true, deep: true }-);-</script>--<style lang="postcss" scoped>-.sql-editor-tree :deep(.n-tree .v-vl) {- --n-node-content-height: 21px !important;-}-.sql-editor-tree :deep(.n-tree-node-content) {- padding-left: 0 !important;- font-size: 0.875rem;- line-height: 1.25rem;- cursor: default !important;-}-.sql-editor-tree :deep(.n-tree-node-wrapper) {- padding: 0;-}-.sql-editor-tree :deep(.n-tree-node-indent) {- width: 1rem;-}-.sql-editor-tree :deep(.n-tree-node-switcher--hide) {- width: 0.5rem !important;-}-.sql-editor-tree :deep(.n-tree-node-content__prefix) {- flex-shrink: 0;- margin-right: 0.25rem !important;-}-.sql-editor-tree.project- :deep(.n-tree-node[data-node-type="project"] .n-tree-node-content__prefix) {- display: none;-}-.sql-editor-tree :deep(.n-tree-node-content__text) {- overflow: hidden;- text-overflow: ellipsis;- white-space: nowrap;- margin-right: 0.25rem;-}-.sql-editor-tree :deep(.n-tree-node--pending) {- background-color: transparent !important;-}-.sql-editor-tree :deep(.n-tree-node--pending:hover) {- background-color: var(--n-node-color-hover) !important;-}-.sql-editor-tree :deep(.n-tree-node--selected),-.sql-editor-tree :deep(.n-tree-node--selected:hover) {- background-color: var(--n-node-color-active) !important;- font-weight: 500;-}-</style>diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseGroupTable.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseGroupTable.vuedeleted file mode 100644index 6fb4d240ab..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseGroupTable.vue+++ /dev/null@@ -1,76 +0,0 @@-<template>- <div- class="w-full"- >- <div class="w-full flex flex-row justify-between items-center mb-3">- <p class="textinfolabel">- {{ $t("database-group.select") }}- </p>- <SearchBox- v-model:value="search"- :placeholder="$t('common.filter-by-name')"- />- </div>- <DatabaseGroupDataTable- :database-group-list="filteredDbGroupList"- :single-selection="false"- :show-selection="true"- :show-external-link="true"- :page-size="100"- :loading="!ready"- :on-row-click="handleDatabaseGroupClick"- :selected-database-group-names="databaseGroupNames"- @update:selected-database-group-names="(groups) => $emit('update:databaseGroupNames', groups)"- />- </div>-</template>--<script lang="tsx" setup>-import { computed, ref } from "vue";-import DatabaseGroupDataTable from "@/components/DatabaseGroup/DatabaseGroupDataTable.vue";-import { SearchBox } from "@/components/v2";-import { useDBGroupListByProject, useSQLEditorStore } from "@/store/modules";-import type { DatabaseGroup } from "@/types/proto-es/v1/database_group_service_pb";-import { DatabaseGroupView } from "@/types/proto-es/v1/database_group_service_pb";--defineProps<{- databaseGroupNames: string[];-}>();--const emit = defineEmits<{- (event: "select", databaseGroupName: string): Promise<void>;- (- event: "update:databaseGroupNames",- databaseGroupNames: string[]- ): Promise<void>;-}>();--const editorStore = useSQLEditorStore();--const search = ref("");--const { dbGroupList, ready } = useDBGroupListByProject(- computed(() => editorStore.project),- DatabaseGroupView.FULL-);--const filteredDbGroupList = computed(() => {- const filter = search.value.trim().toLowerCase();- if (!filter) {- return dbGroupList.value;- }- return dbGroupList.value.filter((group) => {- return (- group.name.toLowerCase().includes(filter) ||- group.title.toLowerCase().includes(filter)- );- });-});--const handleDatabaseGroupClick = (- _: MouseEvent,- databaseGroup: DatabaseGroup-) => {- emit("select", databaseGroup.name);-};-</script>\ No newline at end of filediff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseGroupTag.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseGroupTag.vuedeleted file mode 100644index 5918ba0ef3..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseGroupTag.vue+++ /dev/null@@ -1,35 +0,0 @@-<template>- <NTooltip v-if="databaseGroup">- <template #trigger>- <NTag closable :disabled="disabled" @close="() => $emit('uncheck', databaseGroupName)">- <div class="flex items-center gap-x-1">- <BoxesIcon class="w-4" />- {{ databaseGroup.title }}- </div>- </NTag>- </template>- {{ $t("common.database-group") }}- </NTooltip>-</template>--<script lang="tsx" setup>-import { BoxesIcon } from "lucide-vue-next";-import { NTag, NTooltip } from "naive-ui";-import { computed } from "vue";-import { useDatabaseGroupByName } from "@/store";-import { DatabaseGroupView } from "@/types/proto-es/v1/database_group_service_pb";--const props = defineProps<{- databaseGroupName: string;- disabled: boolean;-}>();--defineEmits<{- (event: "uncheck", databaseGroupName: string): void;-}>();--const { databaseGroup } = useDatabaseGroupByName(- computed(() => props.databaseGroupName),- DatabaseGroupView.FULL-);-</script>diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.vuedeleted file mode 100644index 26bde0aa98..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/DatabaseHoverPanel.vue+++ /dev/null@@ -1,160 +0,0 @@-<template>- <div- v-show="show && database"- ref="popoverRef"- v-zindexable="{ enabled: true }"- class="fixed border border-gray-100 rounded-sm bg-white p-2 shadow-sm transition-all text-sm"- :class="!show && 'pointer-events-none'"- :style="{- left: `${displayPosition.x}px`,- top: `${displayPosition.y}px`,- }"- >- <template v-if="database">- <div- class="grid min-w-56 max-w-[18rem] gap-x-2 gap-y-1"- style="grid-template-columns: auto 1fr"- >- <div class="contents">- <div class="text-gray-500 font-medium">- {{ $t("common.environment") }}- </div>- <div class="text-main text-right">- <EnvironmentV1Name- :environment="environment!"- :link="false"- />- </div>- </div>- <div class="contents">- <div class="text-gray-500 font-medium">- {{ $t("common.instance") }}- </div>- <div class="text-main text-right">- <InstanceV1Name- :instance="instanceResource!"- :link="false"- />- </div>- </div>- <div v-if="!hasProjectContext && project" class="contents">- <div class="text-gray-500 font-medium">- {{ $t("common.project") }}- </div>- <div class="text-main text-right">- <ProjectV1Name :project="project" :link="false" />- </div>- </div>- <div class="contents">- <div class="text-gray-500 font-medium">{{ $t("common.labels") }}</div>- <div class="text-main flex flex-row justify-end flex-wrap gap-1">- <div- v-for="(value, key) in database.labels"- :key="key"- class="text-xs py-px px-1 bg-gray-200/75 rounded-xs"- >- <span>{{ key }}</span>- <template v-if="value">- <span>:</span>- <span>{{ value }}</span>- </template>- </div>- </div>- </div>- </div>- </template>- </div>-</template>--<script setup lang="ts">-import { onClickOutside, useElementSize, useEventListener } from "@vueuse/core";-import { zindexable as vZindexable } from "vdirs";-import { computed, ref } from "vue";-import {- EnvironmentV1Name,- InstanceV1Name,- ProjectV1Name,-} from "@/components/v2";-import { useSQLEditorStore } from "@/store";-import type { Position, SQLEditorTreeNodeTarget } from "@/types";-import {- getDatabaseEnvironment,- getDatabaseProject,- getInstanceResource,- minmax,-} from "@/utils";-import { useHoverStateContext } from "./hover-state";--const props = defineProps<{- offsetX: number;- offsetY: number;- margin: number;-}>();--const emit = defineEmits<{- (event: "click-outside", e: MouseEvent): void;-}>();--const editorStore = useSQLEditorStore();-const { state, position, update } = useHoverStateContext();--const popoverRef = ref<HTMLDivElement>();-onClickOutside(popoverRef, (e) => {- emit("click-outside", e);-});-const { height: popoverHeight } = useElementSize(popoverRef, undefined, {- box: "border-box",-});--const show = computed(- () =>- state.value !== undefined &&- position.value.x !== 0 &&- position.value.y !== 0-);-const database = computed(() => {- if (!state.value?.node) return undefined;- const { type, target } = state.value.node.meta;- if (type !== "database") return undefined;- return target as SQLEditorTreeNodeTarget<"database">;-});--const environment = computed(() => {- if (!database.value) return undefined;- return getDatabaseEnvironment(database.value);-});--const instanceResource = computed(() => {- if (!database.value) return undefined;- return getInstanceResource(database.value);-});--const project = computed(() => {- if (!database.value) return undefined;- return getDatabaseProject(database.value);-});--const hasProjectContext = computed(() => {- return !!editorStore.project;-});--const displayPosition = computed(() => {- const p: Position = {- x: position.value.x + props.offsetX,- y: position.value.y + props.offsetY,- };- const yMin = props.margin;- const yMax = window.innerHeight - popoverHeight.value - props.margin;- p.y = minmax(p.y, yMin, yMax);-- return p;-});--useEventListener(popoverRef, "mouseenter", () => {- // Keep the hover panel visible with a small delay to prevent flicker- update(state.value, "before", 50);-});-useEventListener(popoverRef, "mouseleave", () => {- update(undefined, "after");-});-</script>diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/hover-state.ts b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/hover-state.tsdeleted file mode 100644index 413343b2b3..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/hover-state.ts+++ /dev/null@@ -1,19 +0,0 @@-import type { SQLEditorTreeNode } from "@/types";-import {- provideHoverStateContext as _provideHoverStateContext,- useHoverStateContext as _useHoverStateContext,-} from "../../../EditorCommon";--export const KEY = "connection-pane";--export type HoverState = {- node?: SQLEditorTreeNode;-};--export const useHoverStateContext = () => {- return _useHoverStateContext<HoverState>(KEY);-};--export const provideHoverStateContext = () => {- return _provideHoverStateContext<HoverState>(KEY);-};diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/index.ts b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/index.tsdeleted file mode 100644index c3ebae71c9..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/DatabaseHoverPanel/index.ts+++ /dev/null@@ -1,5 +0,0 @@-import DatabaseHoverPanel from "./DatabaseHoverPanel.vue";--export * from "./hover-state";-export { DatabaseHoverPanel };-export default DatabaseHoverPanel;diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/DatabaseNode.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/DatabaseNode.vuedeleted file mode 100644index 9f02599125..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/DatabaseNode.vue+++ /dev/null@@ -1,72 +0,0 @@-<template>- <div class="flex items-center max-w-full overflow-hidden gap-x-1">- <NTooltip v-if="tabStore.supportBatchMode" :disabled="!checkTooltip" :placement="'bottom-start'">- <template #trigger>- <NCheckbox- class="mr-2"- :checked="checked"- :disabled="checkDisabled"- @click.stop.prevent=""- @update:checked="$emit('update:checked', $event)"- />- </template>- {{ checkTooltip }}- </NTooltip>-- <RichDatabaseName- class="cursor-pointer tree-node-database"- :database="database"- :show-instance="true"- :show-engine-icon="true"- :show-environment="false"- :show-arrow="true"- :keyword="keyword"- @click.stop.prevent="$emit('click')"- />-- <ReactPageMount- v-if="!canQuery"- page="RequestQueryButton"- class="ml-auto"- :text="true"- :permissionDeniedDetail="create(PermissionDeniedDetailSchema, {- resources: [database.name],- requiredPermissions: ['bb.sql.select']- })"- size="sm"- />- </div>-</template>--<script setup lang="ts">-import { create } from "@bufbuild/protobuf";-import { NCheckbox, NTooltip } from "naive-ui";-import { computed } from "vue";-import { RichDatabaseName } from "@/components/v2";-import ReactPageMount from "@/react/ReactPageMount.vue";-import { useSQLEditorTabStore } from "@/store";-import type { SQLEditorTreeNode as TreeNode } from "@/types";-import { PermissionDeniedDetailSchema } from "@/types/proto-es/v1/common_pb";-import { isDatabaseV1Queryable } from "@/utils";--const props = defineProps<{- node: TreeNode;- keyword: string;- checked?: boolean;- checkDisabled?: boolean;- checkTooltip?: string;-}>();--defineEmits<{- (event: "click"): void;- (event: "update:checked", checked: boolean): void;-}>();--const tabStore = useSQLEditorTabStore();--const database = computed(- () => (props.node as TreeNode<"database">).meta.target-);--const canQuery = computed(() => isDatabaseV1Queryable(database.value));-</script>diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/InstanceNode.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/InstanceNode.vuedeleted file mode 100644index 389442488c..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/InstanceNode.vue+++ /dev/null@@ -1,40 +0,0 @@-<template>- <div class="flex items-center max-w-full overflow-hidden gap-x-1">- <EnvironmentV1Name- v-if="!hasEnvironmentContext"- :environment="environment"- :link="false"- class="text-control-light"- />- <InstanceV1Name :link="false" :instance="instance" :keyword="keyword" />- </div>-</template>--<script setup lang="ts">-import { computed } from "vue";-import { EnvironmentV1Name, InstanceV1Name } from "@/components/v2";-import { useEnvironmentV1Store } from "@/store";-import type { SQLEditorTreeNode as TreeNode } from "@/types";--const props = defineProps<{- node: TreeNode;- keyword: string;-}>();--const instance = computed(() => {- const target = (props.node as TreeNode<"instance">).meta.target;- // Add $typeName to match InstanceResource type expected by InstanceV1Name- return {- ...target,- $typeName: "bytebase.v1.InstanceResource" as const,- };-});--const environment = computed(() =>- useEnvironmentV1Store().getEnvironmentByName(instance.value.environment ?? "")-);--const hasEnvironmentContext = computed(() => {- return true;-});-</script>diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/Label.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/Label.vuedeleted file mode 100644index bba20782c2..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/Label.vue+++ /dev/null@@ -1,51 +0,0 @@-<template>- <template v-if="type === 'instance'">- <InstanceNode :node="node" :keyword="keyword" />- </template>- <template v-if="type === 'environment'">- <EnvironmentV1Name- :environment="(node as TreeNode<'environment'>).meta.target"- :keyword="keyword"- :link="false"- />- </template>- <template v-if="type === 'database'">- <DatabaseNode- v-bind="$attrs"- :node="node"- :keyword="keyword"- :checked="checked"- :check-disabled="checkDisabled"- :check-tooltip="checkTooltip"- @click="$emit('click')"- @update:checked="event => $emit('update:checked', event)"- />- </template>- <template v-if="type === 'label'">- <LabelNode :node="node" :keyword="keyword" />- </template>-</template>--<script lang="ts" setup>-import { computed } from "vue";-import { EnvironmentV1Name } from "@/components/v2";-import type { SQLEditorTreeNode as TreeNode } from "@/types";-import DatabaseNode from "./DatabaseNode.vue";-import InstanceNode from "./InstanceNode.vue";-import LabelNode from "./LabelNode.vue";--const props = defineProps<{- node: TreeNode;- keyword: string;- checked: boolean;- checkDisabled?: boolean;- checkTooltip?: string;-}>();--defineEmits<{- (event: "click"): void;- (event: "update:checked", checked: boolean): void;-}>();--const type = computed(() => props.node.meta.type);-</script>diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/LabelNode.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/LabelNode.vuedeleted file mode 100644index 83d4f7d6d1..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/LabelNode.vue+++ /dev/null@@ -1,27 +0,0 @@-<template>- <div class="truncate">- <span>{{ label.key }}</span>- <span class="mr-0.5">:</span>- <HighlightLabelText- v-if="label.value"- :text="label.value"- :keyword="keyword"- />- <span v-else class="text-control-placeholder">- {{ $t("label.empty-label-value") }}- </span>- </div>-</template>--<script setup lang="ts">-import { computed } from "vue";-import { HighlightLabelText } from "@/components/v2";-import type { SQLEditorTreeNode as TreeNode } from "@/types";--const props = defineProps<{- node: TreeNode;- keyword: string;-}>();--const label = computed(() => (props.node as TreeNode<"label">).meta.target);-</script>diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/index.ts b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/index.tsdeleted file mode 100644index 448927e184..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/TreeNode/index.ts+++ /dev/null@@ -1,3 +0,0 @@-import Label from "./Label.vue";--export { Label };diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/actions.tsx b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/actions.tsxdeleted file mode 100644index 414794d574..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/actions.tsx+++ /dev/null@@ -1,224 +0,0 @@-import {- ExternalLinkIcon,- LinkIcon,- SquarePenIcon,- WrenchIcon,-} from "lucide-vue-next";-import type { DropdownOption } from "naive-ui";-import { computed, ref } from "vue";-import { useRouter } from "vue-router";-import { t } from "@/plugins/i18n";-import { PROJECT_V1_ROUTE_DATABASE_DETAIL } from "@/router/dashboard/projectV1";-import { useSQLEditorStore, useSQLEditorTabStore } from "@/store";-import {- type BatchQueryContext,- DEFAULT_SQL_EDITOR_TAB_MODE,- instanceOfSQLEditorTreeNode,- isConnectableSQLEditorTreeNode,- type Position,- type SQLEditorConnection,- type SQLEditorTabMode as TabMode,- type SQLEditorTreeNode as TreeNode,-} from "@/types";-import type { Database } from "@/types/proto-es/v1/database_service_pb";-import {- extractDatabaseResourceName,- extractInstanceResourceName,- extractProjectResourceName,- getInstanceResource,- instanceV1HasAlterSchema,- instanceV1HasReadonlyMode,-} from "@/utils";-import { type SQLEditorContext, useSQLEditorContext } from "../../context";--type DropdownOptionWithTreeNode = DropdownOption & {- onSelect: () => void;-};--export const useDropdown = () => {- const router = useRouter();- const editorContext = useSQLEditorContext();-- const { events: editorEvents, showConnectionPanel } = editorContext;-- const show = ref(false);- const position = ref<Position>({- x: 0,- y: 0,- });- const context = ref<TreeNode>();-- const options = computed((): DropdownOptionWithTreeNode[] => {- const { allowAdmin } = useSQLEditorStore();- const node = context.value;- if (!node) {- return [];- }- const { type, target } = node.meta;- // Don't show any context menu actions for disabled- // instances/databases- if (node.disabled) {- return [];- }-- const items: DropdownOptionWithTreeNode[] = [];-- if (isConnectableSQLEditorTreeNode(node)) {- const database = node.meta.target as Database;- const instance = instanceOfSQLEditorTreeNode(node);- if (instance && instanceV1HasReadonlyMode(instance)) {- items.push({- key: "connect",- label: t("database.select"),- icon: () => <LinkIcon class="w-4 h-4" />,- onSelect: () => {- setConnection({- database,- context: editorContext,- newTab: false,- });- showConnectionPanel.value = false;- },- });- items.push({- key: "connect-in-new-tab",- label: t("sql-editor.open-in-new-tab"),- icon: () => <LinkIcon class="w-4 h-4" />,- onSelect: () => {- setConnection({- database,- newTab: true,- context: editorContext,- });- showConnectionPanel.value = false;- },- });- }- if (allowAdmin) {- items.push({- key: "connect-in-admin-mode",- label: t("sql-editor.connect-in-admin-mode"),- icon: () => <WrenchIcon class="w-4 h-4" />,- onSelect: () => {- setConnection({- database,- mode: "ADMIN",- context: editorContext,- newTab: false,- });- showConnectionPanel.value = false;- },- });- }- }- if (type === "database") {- const database = target as Database;- const { instance, databaseName } = extractDatabaseResourceName(- database.name- );- items.push({- key: "view-database-detail",- label: t("sql-editor.view-database-detail"),- icon: () => <ExternalLinkIcon class="w-4 h-4" />,- onSelect: () => {- const route = router.resolve({- name: PROJECT_V1_ROUTE_DATABASE_DETAIL,- params: {- projectId: extractProjectResourceName(database.project),- instanceId: extractInstanceResourceName(instance),- databaseName,- },- });- const url = route.href;- window.open(url, "_blank");- },- });- if (instanceV1HasAlterSchema(getInstanceResource(database))) {- items.push({- key: "alter-schema",- label: t("database.edit-schema"),- icon: () => <SquarePenIcon class="w-4 h-4" />,- onSelect: () => {- const db = node.meta.target as Database;- editorEvents.emit("alter-schema", {- databaseName: db.name,- schema: "",- table: "",- });- showConnectionPanel.value = false;- },- });- }- }- return items;- });-- const handleSelect = (key: string) => {- const option = options.value.find((item) => item.key === key);- if (!option) {- return;- }- option.onSelect();- show.value = false;- };-- const handleClickoutside = () => {- show.value = false;- };-- return { show, position, context, options, handleSelect, handleClickoutside };-};--// setConnection will:-// - when newTab == false && exist current tab: connect to the current tab-// - otherwise create a new worksheet then open the tab-export const setConnection = (options: {- database?: Database;- mode?: TabMode;- newTab: boolean;- context: SQLEditorContext;- batchQueryContext?: BatchQueryContext;-}) => {- const {- database,- mode = DEFAULT_SQL_EDITOR_TAB_MODE,- newTab = false,- context,- } = options;- const connection: SQLEditorConnection = {- instance: database- ? extractDatabaseResourceName(database.name).instance- : "",- database: database?.name ?? "",- };- const tabStore = useSQLEditorTabStore();- const batchQueryContext: BatchQueryContext = Object.assign(- { databases: [] },- tabStore.currentTab?.batchQueryContext,- options.batchQueryContext- );-- const createOrUpdate = () => {- if (!newTab && tabStore.currentTab) {- return context.maybeUpdateWorksheet({- tabId: tabStore.currentTab.id,- worksheet: tabStore.currentTab.worksheet,- title: tabStore.currentTab.title,- database: connection.database,- statement: tabStore.currentTab.statement,- });- }-- // create new worksheet and set connection- return context.createWorksheet({- database: connection.database,- });- };-- createOrUpdate().then((tab) => {- if (tab) {- tabStore.updateTab(tab.id, { mode, batchQueryContext });- context.asidePanelTab.value = "SCHEMA";- }- });-};diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/index.ts b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/index.tsdeleted file mode 100644index a0b290cb40..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/index.ts+++ /dev/null@@ -1,3 +0,0 @@-import ConnectionPane from "./ConnectionPane.vue";--export default ConnectionPane;diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/tree.ts b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/tree.tsdeleted file mode 100644index 4ed4707663..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPane/tree.ts+++ /dev/null@@ -1,138 +0,0 @@-import { useDebounceFn } from "@vueuse/core";-import { storeToRefs } from "pinia";-import type { ComputedRef, Ref } from "vue";-import { computed, ref, watch } from "vue";-import {- buildTreeImpl,- type DatabaseFilter,- mapTreeNodeByType,- useCurrentUserV1,- useDatabaseV1Store,- useEnvironmentV1Store,- useSQLEditorStore,-} from "@/store";-import type {- StatefulSQLEditorTreeFactor as StatefulFactor,- SQLEditorTreeNode as TreeNode,-} from "@/types";-import { DEBOUNCE_SEARCH_DELAY } from "@/types";-import type { Database } from "@/types/proto-es/v1/database_service_pb";-import {- getDefaultPagination,- isDatabaseV1Queryable,- storageKeySqlEditorConnExpanded,- useDynamicLocalStorage,-} from "@/utils";--const defaultEnvironmentFactor: StatefulFactor = {- factor: "environment",- disabled: false,-};--export type TreeByEnvironment = {- tree: ComputedRef<TreeNode[]>;- expandedState: Ref<{- initialized: boolean;- expandedKeys: string[];- }>;- buildTree: (showMissingQueryDatabases: boolean) => void;- prepareDatabases: (filter?: DatabaseFilter) => Promise<void>;- fetchDatabases: (filter?: DatabaseFilter) => Promise<void>;- fetchDataState: ComputedRef<{- loading: boolean;- nextPageToken?: string;- }>;-};--export const useSQLEditorTreeByEnvironment = (- environment: string-): TreeByEnvironment => {- const databaseStore = useDatabaseV1Store();- const { project } = storeToRefs(useSQLEditorStore());- const currentUser = useCurrentUserV1();- const environmentStore = useEnvironmentV1Store();-- const tree = ref<TreeNode[]>([]);- const databaseList = ref<Database[]>([]);- const fetchDataState = ref<{- loading: boolean;- nextPageToken?: string;- }>({ loading: false });-- const expandedState = useDynamicLocalStorage<{- initialized: boolean;- expandedKeys: string[];- }>(- computed(() =>- storageKeySqlEditorConnExpanded(environment, currentUser.value.email)- ),- {- initialized: false,- expandedKeys: [],- }- );-- watch(- () => expandedState.value.expandedKeys,- () => {- expandedState.value.initialized = true;- },- { deep: true }- );-- const fetchDatabases = useDebounceFn(async (filter?: DatabaseFilter) => {- fetchDataState.value.loading = true;- const pageToken = fetchDataState.value.nextPageToken;-- try {- const { databases, nextPageToken } = await databaseStore.fetchDatabases({- parent: project.value,- pageToken,- pageSize: getDefaultPagination(),- filter: {- ...filter,- environment,- },- });- if (pageToken) {- databaseList.value.push(...databases);- } else {- databaseList.value = [...databases];- }- fetchDataState.value.nextPageToken = nextPageToken;- } catch {- databaseList.value = [];- } finally {- fetchDataState.value.loading = false;- }- }, DEBOUNCE_SEARCH_DELAY);-- const prepareDatabases = async (filter?: DatabaseFilter) => {- fetchDataState.value.nextPageToken = "";- await fetchDatabases(filter);- };-- const buildTree = (showMissingQueryDatabases: boolean) => {- let list = [...databaseList.value];- if (!showMissingQueryDatabases) {- list = list.filter((db) => isDatabaseV1Queryable(db));- }- tree.value = buildTreeImpl(list, [defaultEnvironmentFactor.factor]);-- if (tree.value.length === 0) {- const env = environmentStore.getEnvironmentByName(environment);- const rootNode = mapTreeNodeByType("environment", env, undefined);- rootNode.children = [];- tree.value = [rootNode];- }- };-- return {- tree: computed(() => tree.value),- expandedState,- buildTree,- prepareDatabases,- fetchDatabases,- fetchDataState: computed(() => fetchDataState.value),- };-};diff --git a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPanel.vue b/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPanel.vuedeleted file mode 100644index 7faa28f333..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/ConnectionPanel.vue+++ /dev/null@@ -1,79 +0,0 @@-<template>- <Drawer- :show="show"- :close-on-esc="false"- placement="right"- style="--n-body-padding: 4px 0"- @update:show="$emit('update:show', $event)"- >- <DrawerContent- :style="{- width: contentWidth,- maxWidth: '800px',- }"- class="connection-panel-content"- >- <template #header>- <span>{{ $t("database.select") }}</span>- <NTooltip v-if="allowManageInstance" placement="bottom">- <template #trigger>- <NButton- quaternary- size="small"- style="--n-padding: 0 4px"- @click="$router.push({ name: INSTANCE_ROUTE_DASHBOARD })"- >- <template #icon>- <SettingsIcon class="w-4" />- </template>- </NButton>- </template>- <template #default>- {{ $t("sql-editor.manage-connections") }}- </template>- </NTooltip>- </template>- <ConnectionPane :show="show" />- </DrawerContent>- </Drawer>-</template>--<script setup lang="ts">-import { useWindowSize } from "@vueuse/core";-import { SettingsIcon } from "lucide-vue-next";-import { NButton, NTooltip } from "naive-ui";-import { computed } from "vue";-import { Drawer, DrawerContent } from "@/components/v2";-import { INSTANCE_ROUTE_DASHBOARD } from "@/router/dashboard/workspaceRoutes";-import { hasWorkspacePermissionV2 } from "@/utils";-import ConnectionPane from "./ConnectionPane";--defineProps<{- show: boolean;-}>();--defineEmits<{- (event: "update:show", show: boolean): void;-}>();--const { width: winWidth } = useWindowSize();-const contentWidth = computed(() => {- if (winWidth.value >= 800) {- return "50vw";- }- return "calc(100vw - 4rem)";-});--const allowManageInstance = computed(() => {- return hasWorkspacePermissionV2("bb.instances.list");-});-</script>--<style scoped lang="postcss">-.connection-panel-content :deep(.n-drawer-header__main) {- flex: 1 1 0%;- display: flex;- align-items: center;- justify-content: space-between;-}-</style>diff --git a/frontend/src/views/sql-editor/ConnectionPanel/index.ts b/frontend/src/views/sql-editor/ConnectionPanel/index.tsdeleted file mode 100644index ecc11c26cb..0000000000--- a/frontend/src/views/sql-editor/ConnectionPanel/index.ts+++ /dev/null@@ -1,3 +0,0 @@-import ConnectionPanel from "./ConnectionPanel.vue";--export default ConnectionPanel;diff --git a/frontend/src/views/sql-editor/SQLEditorHomePage.vue b/frontend/src/views/sql-editor/SQLEditorHomePage.vueindex 927b144384..d01a06f41a 100644--- a/frontend/src/views/sql-editor/SQLEditorHomePage.vue+++ b/frontend/src/views/sql-editor/SQLEditorHomePage.vue@@ -40,7 +40,7 @@</template><template #2><div class="h-full relative flex flex-col">- <TabList />+ <ReactPageMount page="TabList" container-class="w-full" /><EditorPanel /></div></template>@@ -54,7 +54,10 @@<li>[Page]currentTab.connection: {{ currentTab?.connection }}</li></teleport>- <ConnectionPanel v-model:show="showConnectionPanel" />+ <!-- ConnectionPanel reads its open state directly from uiStore via+ useVueState, so no prop wiring is needed here. The Sheet portals+ out of the SQL Editor layout into the overlay layer. -->+ <ReactPageMount page="ConnectionPanel" container-class="" /></div><IAMRemindModal v-if="projectContextReady" :project-name="projectName" />@@ -76,6 +79,7 @@ import { applyPlanTitleToQuery } from "@/components/Plan/logic/title";import Quickstart from "@/components/Quickstart.vue";import { Drawer } from "@/components/v2";import { useEmitteryEventListener } from "@/composables/useEmitteryEventListener";+import ReactPageMount from "@/react/ReactPageMount.vue";import { PROJECT_V1_ROUTE_PLAN_DETAIL_SPEC_DETAIL } from "@/router/dashboard/projectV1";import {useProjectV1Store as projectV1Store,@@ -89,11 +93,9 @@ import {extractProjectResourceName,} from "@/utils";import AsidePanel from "./AsidePanel";-import ConnectionPanel from "./ConnectionPanel";import { useSQLEditorContext } from "./context";import EditorPanel from "./EditorPanel";import { provideCurrentTabViewStateContext } from "./EditorPanel/context/viewState";-import TabList from "./TabList";type LocalState = {sizebarSize: number;@@ -116,11 +118,8 @@ const projectStore = projectV1Store();const tabStore = useSQLEditorTabStore();const editorStore = useSQLEditorStore();-const {- events: editorEvents,- showConnectionPanel,- pendingInsertAtCaret,-} = useSQLEditorContext();+const { events: editorEvents, pendingInsertAtCaret } = useSQLEditorContext();+const { project: projectName, projectContextReady } = storeToRefs(editorStore);const { currentTab, isDisconnected } = storeToRefs(tabStore);diff --git a/frontend/src/views/sql-editor/TabList/ContextMenu.vue b/frontend/src/views/sql-editor/TabList/ContextMenu.vuedeleted file mode 100644index 159d0b8114..0000000000--- a/frontend/src/views/sql-editor/TabList/ContextMenu.vue+++ /dev/null@@ -1,118 +0,0 @@-<template>- <NDropdown- v-if="state"- trigger="manual"- placement="bottom-start"- :show="true"- :x="state?.x"- :y="state?.y"- :options="options"- @clickoutside="state = undefined"- @update:show="handleUpdateShow"- @select="handleSelect"- />-</template>--<script setup lang="ts">-import type { DropdownOption } from "naive-ui";-import { NDropdown } from "naive-ui";-import { computed, nextTick } from "vue";-import { useI18n } from "vue-i18n";-import type { SQLEditorTab } from "@/types";-import type { CloseTabAction } from "./context";-import { useTabListContext } from "./context";--const { t } = useI18n();-const { contextMenu: state, events } = useTabListContext();--const options = computed((): DropdownOption[] => {- if (!state.value) {- return [];- }-- const CLOSE: DropdownOption = {- key: "CLOSE",- label: t("sql-editor.tab.context-menu.actions.close"),- };- const CLOSE_OTHERS: DropdownOption = {- key: "CLOSE_OTHERS",- label: t("sql-editor.tab.context-menu.actions.close-others"),- };- const CLOSE_TO_THE_RIGHT: DropdownOption = {- key: "CLOSE_TO_THE_RIGHT",- label: t("sql-editor.tab.context-menu.actions.close-to-the-right"),- };- const CLOSE_SAVED: DropdownOption = {- key: "CLOSE_SAVED",- label: t("sql-editor.tab.context-menu.actions.close-saved"),- };- const CLOSE_ALL: DropdownOption = {- key: "CLOSE_ALL",- label: t("sql-editor.tab.context-menu.actions.close-all"),- };-- const options = [- CLOSE,- CLOSE_OTHERS,- CLOSE_TO_THE_RIGHT,- CLOSE_SAVED,- CLOSE_ALL,- ];-- const { mode, viewState } = state.value.tab;- if (mode === "WORKSHEET" && viewState.view === "CODE") {- options.push(- {- type: "divider",- key: "DIVIDER",- },- {- key: "RENAME",- label: t("sql-editor.tab.context-menu.actions.rename"),- }- );- }-- return options;-});--const show = (tab: SQLEditorTab, index: number, e: MouseEvent) => {- e.preventDefault();- e.stopPropagation();- state.value = undefined;- nextTick(() => {- const { pageX, pageY } = e;- state.value = {- x: pageX,- y: pageY,- tab,- index,- };- });-};--const hide = () => {- state.value = undefined;-};--const handleUpdateShow = (show: boolean) => {- if (!show) {- hide();- }-};--const handleSelect = (action: CloseTabAction | "RENAME") => {- if (!state.value) return;- const { tab, index } = state.value;- if (action === "RENAME") {- events.emit("rename-tab", { tab, index });- } else {- events.emit("close-tab", { tab, index, action });- }-};--defineExpose({- show,- hide,-});-</script>diff --git a/frontend/src/views/sql-editor/TabList/TabItem/AdminLabel.vue b/frontend/src/views/sql-editor/TabList/TabItem/AdminLabel.vuedeleted file mode 100644index 7f8da1921e..0000000000--- a/frontend/src/views/sql-editor/TabList/TabItem/AdminLabel.vue+++ /dev/null@@ -1,62 +0,0 @@-<template>- <label class="flex items-center text-sm h-5 ml-0.5 whitespace-nowrap">- <template v-if="!hideEnvironment">- <EnvironmentV1Name- :environment="environment"- :link="false"- />- <ChevronRightIcon class="shrink-0 h-4 w-4 opacity-70" />- </template>- <template v-if="isValidInstanceName(instance.name)">- <span>{{ instance.title }}</span>- <ChevronRightIcon class="shrink-0 h-4 w-4 opacity-70" />- </template>- <template v-if="isValidDatabaseName(database.name)">- <span>{{ databaseName }}</span>- </template>- </label>-</template>--<script lang="ts" setup>-import { ChevronRightIcon } from "lucide-vue-next";-import { computed } from "vue";-import { EnvironmentV1Name } from "@/components/v2";-import { useDatabaseV1ByName } from "@/store";-import {- isValidDatabaseName,- isValidInstanceName,- type SQLEditorTab,- UNKNOWN_ID,-} from "@/types";-import {- extractDatabaseResourceName,- getDatabaseEnvironment,- getInstanceResource,-} from "@/utils";--const props = defineProps<{- tab: SQLEditorTab;-}>();--const connection = computed(() => props.tab.connection);--const { database } = useDatabaseV1ByName(- computed(() => connection.value.database)-);--const instance = computed(() => {- return getInstanceResource(database.value);-});--const environment = computed(() => {- return getDatabaseEnvironment(database.value);-});--const databaseName = computed(() => {- return extractDatabaseResourceName(database.value.name).databaseName;-});--const hideEnvironment = computed(() => {- return environment.value?.id === String(UNKNOWN_ID);-});-</script>diff --git a/frontend/src/views/sql-editor/TabList/TabItem/Label.vue b/frontend/src/views/sql-editor/TabList/TabItem/Label.vuedeleted file mode 100644index 2732e19ed8..0000000000--- a/frontend/src/views/sql-editor/TabList/TabItem/Label.vue+++ /dev/null@@ -1,161 +0,0 @@-<template>- <div class="label" :class="[tab.status.toLowerCase()]">- <NEllipsis- class="name"- :tooltip="{- placement: 'top',- delay: 250,- }"- :class="state.editing && 'invisible'"- @dblclick="beginEdit"- >- {{ state.title }}- </NEllipsis>-- <input- v-if="state.editing"- ref="inputRef"- v-model="state.title"- type="text"- class="edit"- @blur="confirmEdit"- @keydown.enter="onEnter"- @keydown.esc="onEsc"- />- </div>-</template>-<script lang="ts" setup>-import { create } from "@bufbuild/protobuf";-import { NEllipsis } from "naive-ui";-import { computed, nextTick, reactive, ref, watch } from "vue";-import { useEmitteryEventListener } from "@/composables/useEmitteryEventListener";-import { useSQLEditorTabStore, useWorkSheetStore } from "@/store";-import type { SQLEditorTab } from "@/types";-import { WorksheetSchema } from "@/types/proto-es/v1/worksheet_service_pb";-import { useTabListContext } from "../context";--type LocalState = {- editing: boolean;- title: string;-};--const props = defineProps<{- tab: SQLEditorTab;-}>();--const state = reactive<LocalState>({- editing: false,- title: props.tab.title,-});--const tabStore = useSQLEditorTabStore();-const worksheetV1Store = useWorkSheetStore();-const inputRef = ref<HTMLInputElement>();-const { events } = useTabListContext();--const readonly = computed(() => {- const viewState = props.tab.viewState;- return viewState.view !== "CODE";-});--const isCurrentTab = computed(() => props.tab.id === tabStore.currentTabId);--useEmitteryEventListener(events, "rename-tab", ({ tab }) => {- if (tab.id === props.tab.id) {- tabStore.setCurrentTabId(tab.id);- beginEdit();- }-});--const beginEdit = () => {- if (readonly.value) {- return;- }- state.editing = true;- state.title = props.tab.title;- nextTick(() => {- inputRef.value?.select();- });-};--const confirmEdit = () => {- const { tab } = props;-- const title = state.title.trim();- if (title === "") {- return cancelEdit();- }-- tabStore.updateTab(tab.id, {- title,- });-- if (tab.worksheet) {- worksheetV1Store.patchWorksheet(- create(WorksheetSchema, {- name: tab.worksheet,- title,- }),- ["title"]- );- }-- state.editing = false;-};--const onEnter = (e: KeyboardEvent) => {- if (e.isComposing) return;- (e.target as HTMLInputElement).blur();-};--const onEsc = (e: KeyboardEvent) => {- if (e.isComposing) return;- cancelEdit();-};--const cancelEdit = () => {- state.editing = false;- state.title = props.tab.title;-};--watch(- () => props.tab.title,- (title) => {- state.title = title;- }-);-watch(isCurrentTab, (value) => {- if (!value) {- cancelEdit();- }-});-</script>--<style scoped lang="postcss">-.label {- position: relative;- min-width: 6rem;- max-width: 16rem;- overflow: hidden;- text-overflow: ellipsis;-}--.label :deep(.name) {- width: 100%;- font-size: 0.875rem;- line-height: 1.25rem;-}-.edit {- border: 0;- border-bottom-width: 1px;- position: absolute;- inset: 0;- padding: 0;- font-size: 0.875rem;- line-height: 1.25rem;-}--.label.new :deep(.name) {- font-style: italic;-}-</style>diff --git a/frontend/src/views/sql-editor/TabList/TabItem/Prefix.vue b/frontend/src/views/sql-editor/TabList/TabItem/Prefix.vuedeleted file mode 100644index b1c09c0e43..0000000000--- a/frontend/src/views/sql-editor/TabList/TabItem/Prefix.vue+++ /dev/null@@ -1,48 +0,0 @@-<template>- <div class="opacity-80 flex items-center gap-x-2">- <PencilLineIcon v-if="isDraft" class="w-4 h-4" />- <template v-else>- <UsersIcon- v-if="sheet && !isWorksheetCreator(sheet)"- class="w-4 h-4"- />- <WrenchIcon v-if="tab.mode === 'ADMIN'" class="w-4 h-4" />- </template>- <ReactPageMount page="SheetConnectionIcon" :tab="tab" />- </div>-</template>--<script lang="ts" setup>-import { PencilLineIcon, UsersIcon, WrenchIcon } from "lucide-vue-next";-import { computed } from "vue";-import ReactPageMount from "@/react/ReactPageMount.vue";-import { useWorkSheetStore } from "@/store";-import type { SQLEditorTab } from "@/types";-import { useSheetContext } from "@/views/sql-editor/Sheet";--const props = defineProps<{- tab: SQLEditorTab;-}>();--const sheetV1Store = useWorkSheetStore();-const { isWorksheetCreator } = useSheetContext();--const isDraft = computed(() => {- const { worksheet, viewState } = props.tab;- if (worksheet) {- return false;- }- return viewState.view === "CODE";-});--const sheet = computed(() => {- const { worksheet: sheetName } = props.tab;- if (sheetName) {- const sheet = sheetV1Store.getWorksheetByName(sheetName);- if (sheet) {- return sheet;- }- }- return null;-});-</script>diff --git a/frontend/src/views/sql-editor/TabList/TabItem/Suffix.vue b/frontend/src/views/sql-editor/TabList/TabItem/Suffix.vuedeleted file mode 100644index 7dbda973a9..0000000000--- a/frontend/src/views/sql-editor/TabList/TabItem/Suffix.vue+++ /dev/null@@ -1,104 +0,0 @@-<template>- <div- class="suffix"- :class="[- {- admin: tab.mode === 'ADMIN',- closable: true,- },- tab.status,- ]"- @mouseenter="state.hovering = true"- @mouseleave="state.hovering = false"- >- <LoaderCircleIcon- v-if="icon === 'saving'"- class="icon saving animate-spin"- />- <carbon:dot-mark v-else-if="icon === 'unsaved'" class="icon unsaved" />- <heroicons-solid:x- v-else-if="icon === 'close'"- class="icon close"- @click.stop.prevent="$emit('close')"- />- <span v-else class="icon dummy"></span>- </div>-</template>--<script lang="ts" setup>-import { LoaderCircleIcon } from "lucide-vue-next";-import { computed, reactive } from "vue";-import type { SQLEditorTab } from "@/types";--type LocalState = {- hovering: boolean;-};--type IconType = "unsaved" | "saving" | "close";--const props = defineProps<{- tab: SQLEditorTab;-}>();--const state = reactive<LocalState>({- hovering: false,-});--defineEmits<{- (e: "close"): void;-}>();--const icon = computed((): IconType | undefined => {- const { mode, status } = props.tab;- // Always show saving indicator when saving, even when hovering- if (mode === "WORKSHEET" && status === "SAVING") {- return "saving";- }- if (state.hovering) {- return "close";- }- if (mode === "WORKSHEET" && status === "DIRTY") {- return "unsaved";- }- return "close";-});-</script>--<style scoped lang="postcss">-.suffix {- display: flex;- align-items: center;- min-width: 1.25rem;-}-.icon {- display: block;- width: 1.25rem;- height: 1.25rem;- padding: 0.125rem;- color: rgb(var(--color-gray-500));- border-radius: 0.25rem;-}-.suffix.closable {- cursor: pointer;-}-.suffix.closable.DIRTY .icon {- color: rgb(var(--color-accent));-}-.suffix.closable.SAVING .icon.saving {- color: rgb(var(--color-accent));-}-.suffix.closable .icon:hover {- color: rgb(var(--color-gray-700));- background-color: rgb(var(--color-gray-200));-}-.suffix.admin .icon {- color: rgb(var(--color-gray-400));-}-.suffix.admin .icon:hover {- color: rgb(var(--color-gray-300));- background-color: rgb(var(--color-gray-400) / 0.3);-}-.dummy {- visibility: hidden;-}-</style>diff --git a/frontend/src/views/sql-editor/TabList/TabItem/TabItem.vue b/frontend/src/views/sql-editor/TabList/TabItem/TabItem.vuedeleted file mode 100644index 8c71d5aadc..0000000000--- a/frontend/src/views/sql-editor/TabList/TabItem/TabItem.vue+++ /dev/null@@ -1,133 +0,0 @@-<template>- <div- class="tab-item"- :class="[- {- current: isCurrentTab,- hovering: state.hovering,- },- tab.status.toLowerCase(),- ]"- @mousedown.left="$emit('select', tab, index)"- @mouseenter="state.hovering = true"- @mouseleave="state.hovering = false"- >- <div- class="body flex items-center gap-x-2"- :style="- backgroundColorRgb- ? {- backgroundColor: `rgba(${backgroundColorRgb}, 0.1)`,- borderTopColor: `rgb(${backgroundColorRgb})`,- color: `rgb(${backgroundColorRgb})`,- }- : {}- "- >- <Prefix :tab="tab" />- <Label v-if="tab.mode === 'WORKSHEET'" :tab="tab" />- <AdminLabel v-else :tab="tab" />- <Suffix :tab="tab" @close="$emit('close', tab, index)" />- </div>- </div>-</template>--<script lang="ts" setup>-import { computed, reactive } from "vue";-import { useSQLEditorTabStore } from "@/store";-import { type SQLEditorTab, UNKNOWN_ID } from "@/types";-import {- getConnectionForSQLEditorTab,- getDatabaseEnvironment,- hexToRgb,-} from "@/utils";-import AdminLabel from "./AdminLabel.vue";-import Label from "./Label.vue";-import Prefix from "./Prefix.vue";-import Suffix from "./Suffix.vue";--type LocalState = {- hovering: boolean;-};--const props = defineProps<{- tab: SQLEditorTab;- index: number;-}>();--defineEmits<{- (e: "select", tab: SQLEditorTab, index: number): void;- (e: "close", tab: SQLEditorTab, index: number): void;-}>();--const state = reactive<LocalState>({- hovering: false,-});--const tabStore = useSQLEditorTabStore();--const isCurrentTab = computed(() => props.tab.id === tabStore.currentTabId);--const environment = computed(() => {- const { database } = getConnectionForSQLEditorTab(props.tab);- if (!database) {- return undefined;- }- const environment = getDatabaseEnvironment(database);- if (environment?.id === String(UNKNOWN_ID)) {- return undefined;- }- return environment;-});--const backgroundColorRgb = computed(() => {- if (!isCurrentTab.value) {- return "";- }- if (!environment.value || !environment.value.color) {- return hexToRgb("#4f46e5").join(", ");- }- return hexToRgb(environment.value.color).join(", ");-});-</script>--<style scoped lang="postcss">-.tab-item {- cursor: pointer;- border-right-width: 1px;- background-color: white;- column-gap: 0.5rem;- position: relative;-}-.hovering {- background-color: rgb(var(--color-gray-50));-}-.tab-item.admin {- background-color: rgb(var(--color-dark-bg)) !important;-}--.body {- display: flex;- align-items: center;- justify-content: space-between;- padding-left: 0.5rem;- padding-right: 0.25rem;- border-top-width: 1px;- padding-top: 4px;- height: 36px;-}-.current .body {- position: relative;- background-color: white;- border-top-width: 3px;- padding-top: 2px;-}--.tab-item.admin .body {- color: rgb(var(--color-matrix-green-hover));-}-.tab-item.admin.current .body {- background-color: rgb(var(--color-dark-bg)) !important;- border-top-color: rgb(var(--color-matrix-green-hover));-}-</style>diff --git a/frontend/src/views/sql-editor/TabList/TabList.vue b/frontend/src/views/sql-editor/TabList/TabList.vuedeleted file mode 100644index 6568faeff6..0000000000--- a/frontend/src/views/sql-editor/TabList/TabList.vue+++ /dev/null@@ -1,287 +0,0 @@-<template>- <div- class="bb-sql-editor-tab-list flex justify-between items-center box-border text-gray-500 text-sm border-b pr-2 gap-1"- >- <NScrollbar- ref="scrollbarRef"- :x-scrollable="true"- trigger="hover"- class="scrollbar"- content-class="flex gap-x-1"- @scroll="recalculateScrollState"- >- <VueDraggable- id="tab-list"- ref="tabListRef"- v-model="tabStore.openTabList"- :animation="300"- class="relative flex flex-nowrap overflow-hidden h-9 pt-0.5 hide-scrollbar"- :class="{- 'more-left': scrollState.moreLeft,- 'more-right': scrollState.moreRight,- }"- ghost-class="ghost"- >- <TabItem- v-for="(tab, index) in tabStore.openTabList"- :key="tab.id"- :tab="tab"- :index="index"- :data-tab-id="tab.id"- @select="(tab) => tabStore.setCurrentTabId(tab.id)"- @close="(tab) => handleRemoveTab(tab)"- @contextmenu.stop.prevent="- contextMenuRef?.show(tab, index, $event)- "- />- </VueDraggable>-- <div- class="shrink-0 sticky right-0 bg-white flex items-stretch justify-end"- >- <button- class="bg-gray-200/20 hover:bg-accent/10py-1 px-1.5 border-t border-x rounded-t hover:border-accent"- :disabled="state.loading"- @click="handleAddTab"- >- <PlusIcon class="h-5 w-5" stroke-width="2.5" />- </button>- </div>- </NScrollbar>-- <ReactPageMount- page="HeaderProfileMenuMount"- :page-props="{ size: 'small' }"- />-- <ContextMenu ref="contextMenuRef" />- </div>-</template>--<script lang="ts" setup>-import { useResizeObserver } from "@vueuse/core";-import { PlusIcon } from "lucide-vue-next";-import { NScrollbar, useDialog } from "naive-ui";-import scrollIntoView from "scroll-into-view-if-needed";-import { computed, nextTick, onMounted, reactive, ref, watch } from "vue";-import { VueDraggable } from "vue-draggable-plus";-import { useI18n } from "vue-i18n";-import { useEmitteryEventListener } from "@/composables/useEmitteryEventListener";-import ReactPageMount from "@/react/ReactPageMount.vue";-import { useSQLEditorTabStore } from "@/store";-import type { SQLEditorTab } from "@/types";-import { defer, usePreventBackAndForward } from "@/utils";-import { useSQLEditorContext } from "../context";-import ContextMenu from "./ContextMenu.vue";-import { useTabListContext } from "./context";-import TabItem from "./TabItem/TabItem.vue";--type LocalState = {- hoverTabId: string;- loading: boolean;-};--const tabStore = useSQLEditorTabStore();-const editorContext = useSQLEditorContext();-const context = useTabListContext();--const { t } = useI18n();-const dialog = useDialog();--const state = reactive<LocalState>({- hoverTabId: "",- loading: false,-});-const scrollbarRef = ref<InstanceType<typeof NScrollbar>>();-const tabListRef = ref<InstanceType<typeof VueDraggable>>();-const contextMenuRef = ref<InstanceType<typeof ContextMenu>>();--const scrollState = reactive({- moreLeft: false,- moreRight: false,-});--const scrollElement = computed((): HTMLElement | null | undefined => {- return scrollbarRef.value?.scrollbarInstRef?.containerRef;-});--const handleAddTab = async () => {- if (state.loading) {- return;- }-- state.loading = true;- try {- await editorContext.createWorksheet({});- nextTick(() => {- requestAnimationFrame(() => {- const elem = scrollElement.value;- if (elem) {- elem.scrollTo(elem.scrollWidth, 0);- }- requestAnimationFrame(() => {- recalculateScrollState();- });- });- });- } finally {- state.loading = false;- }-};--const handleRemoveTab = async (tab: SQLEditorTab, focusWhenConfirm = false) => {- const _defer = defer<boolean>();- if (tab.mode === "WORKSHEET" && tab.status !== "CLEAN") {- if (focusWhenConfirm) {- tabStore.setCurrentTabId(tab.id);- }- const $dialog = dialog.create({- title: t("sql-editor.hint-tips.confirm-to-close-unsaved-sheet.title"),- content: t("sql-editor.hint-tips.confirm-to-close-unsaved-sheet.content"),- type: "warning",- autoFocus: false,- closable: false,- maskClosable: false,- closeOnEsc: false,- onPositiveClick() {- remove();- $dialog.destroy();- _defer.resolve(true);- },- onNegativeClick() {- $dialog.destroy();- _defer.resolve(false);- },- positiveText: t("sql-editor.close-sheet"),- negativeText: t("common.cancel"),- showIcon: false,- });- } else {- remove();- _defer.resolve(true);- }-- function remove() {- tabStore.closeTab(tab.id);- nextTick(recalculateScrollState);- }-- return _defer.promise;-};--usePreventBackAndForward(scrollElement);-useResizeObserver(tabListRef, () => {- recalculateScrollState();-});--const recalculateScrollState = () => {- contextMenuRef.value?.hide();-- const element = scrollElement.value;- if (!element) {- return;- }-- const { scrollWidth, offsetWidth, scrollLeft } = element;-- if (scrollLeft === 0) {- scrollState.moreLeft = false;- } else {- scrollState.moreLeft = true;- }-- if (scrollWidth > offsetWidth) {- // The actual width is wider than the visible width- const rightBound = scrollLeft + offsetWidth;- if (rightBound < scrollWidth) {- scrollState.moreRight = true;- } else {- scrollState.moreRight = false;- }- } else {- scrollState.moreRight = false;- }-};--watch(- () => tabStore.currentTabId,- (id) => {- requestAnimationFrame(() => {- // Scroll the selected tab into view if needed.- const tabElements = Array.from(document.querySelectorAll(".tab-item"));- const tabElement = tabElements.find(- (elem) => elem.getAttribute("data-tab-id") === id- );- if (tabElement) {- scrollIntoView(tabElement, {- scrollMode: "if-needed",- });- }- });- },- { immediate: true }-);--onMounted(() => recalculateScrollState());--useEmitteryEventListener(- context.events,- "close-tab",- async ({ tab, index, action }) => {- const { openTabList } = tabStore;-- const remove = async (tab: SQLEditorTab) => {- await handleRemoveTab(tab, true);- await new Promise((r) => requestAnimationFrame(r));- };-- const max = openTabList.length - 1;- switch (action) {- case "CLOSE": {- await remove(tab);- return;- }- case "CLOSE_OTHERS": {- for (let i = max; i > index; i--) {- await remove(openTabList[i]);- }- for (let i = index - 1; i >= 0; i--) {- await remove(openTabList[i]);- }- return;- }- case "CLOSE_TO_THE_RIGHT": {- for (let i = max; i > index; i--) {- await remove(openTabList[i]);- }- return;- }- case "CLOSE_SAVED": {- for (let i = max; i >= 0; i--) {- const tab = openTabList[i];- if (tab.status === "CLEAN") {- await remove(tab);- }- }- return;- }- case "CLOSE_ALL": {- for (let i = max; i >= 0; i--) {- await remove(openTabList[i]);- }- return;- }- }- }-);-</script>--<style lang="postcss">-.bb-sql-editor-tab-list .ghost {- opacity: 0.3;- background-color: white;-}-.bb-sql-editor-tab-list .scrollbar .n-scrollbar-rail--horizontal--bottom {- inset: auto 2px 2px 2px !important;-}-</style>diff --git a/frontend/src/views/sql-editor/TabList/context.ts b/frontend/src/views/sql-editor/TabList/context.tsdeleted file mode 100644index ce4bcb4939..0000000000--- a/frontend/src/views/sql-editor/TabList/context.ts+++ /dev/null@@ -1,47 +0,0 @@-import Emittery from "emittery";-import type { InjectionKey, Ref } from "vue";-import { inject, provide, ref } from "vue";-import type { SQLEditorTab } from "@/types";--export type CloseTabAction =- | "CLOSE"- | "CLOSE_OTHERS"- | "CLOSE_TO_THE_RIGHT"- | "CLOSE_SAVED"- | "CLOSE_ALL";--type TabListEvents = Emittery<{- "close-tab": { tab: SQLEditorTab; index: number; action: CloseTabAction };- "rename-tab": { tab: SQLEditorTab; index: number };-}>;--export type TabListContextMenuState = {- x: number;- y: number;- tab: SQLEditorTab;- index: number;-};--export type TabListContext = {- contextMenu: Ref<TabListContextMenuState | undefined>;- events: TabListEvents;-};--export const KEY = Symbol(- "bb.sql-editor.tab-list"-) as InjectionKey<TabListContext>;--export const useTabListContext = () => {- return inject(KEY)!;-};--export const provideTabListContext = () => {- const context: TabListContext = {- contextMenu: ref(),- events: new Emittery(),- };-- provide(KEY, context);-- return context;-};diff --git a/frontend/src/views/sql-editor/TabList/events.ts b/frontend/src/views/sql-editor/TabList/events.tsnew file mode 100644index 0000000000..83968a575a--- /dev/null+++ b/frontend/src/views/sql-editor/TabList/events.ts@@ -0,0 +1,23 @@+import Emittery from "emittery";+import type { SQLEditorTab } from "@/types";++export type CloseTabAction =+ | "CLOSE"+ | "CLOSE_OTHERS"+ | "CLOSE_TO_THE_RIGHT"+ | "CLOSE_SAVED"+ | "CLOSE_ALL";++export type TabListEventMap = {+ "close-tab": { tab: SQLEditorTab; index: number; action: CloseTabAction };+ "rename-tab": { tab: SQLEditorTab; index: number };+};++/**+ * Module-level tab list event bus. Imported by both the Vue+ * `provideTabListContext` (via `./context`) and React consumers that can't+ * participate in Vue's provide/inject. Single shared instance so emit/on+ * from either side reaches the other — same pattern used for the AI events+ * singleton (see `src/plugins/ai/logic/events.ts`).+ */+export const tabListEvents: Emittery<TabListEventMap> = new Emittery();diff --git a/frontend/src/views/sql-editor/TabList/index.ts b/frontend/src/views/sql-editor/TabList/index.tsdeleted file mode 100644index ac629c99eb..0000000000--- a/frontend/src/views/sql-editor/TabList/index.ts+++ /dev/null@@ -1,3 +0,0 @@-import TabList from "./TabList.vue";--export default TabList;