Skip to content

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

feat(react): add SchemaEditorLite React component suite (#20031)

boojackeb768ebd4956
diff --git a/docs/plans/2026-04-16-schema-editor-react-migration/definition.md b/docs/plans/2026-04-16-schema-editor-react-migration/definition.md
new file mode 100644
index 0000000000..c9383b7700
--- /dev/null
+++ b/docs/plans/2026-04-16-schema-editor-react-migration/definition.md
@@ -0,0 +1,95 @@
+## Background & Context
+
+The frontend is undergoing an incremental migration from Vue 3 to React. Existing React pages (ProjectDatabaseDetailPage, ProjectSyncSchemaPage, IssueDetailPage) already bridge into Vue stores via `useVueState()` and reuse pure-TS utilities from the Vue layer. The migration playbook (`docs/plans/2026-04-08-react-migration-playbook.md`) governs the process: migrate bounded surfaces, reuse existing stores/utilities, delete Vue files only when callers are gone.
+
+The schema editor is one of the most complex interactive surfaces in the product. It provides visual DDL editing (tables, columns, indexes, partitions, views, procedures, functions), an ER diagram viewer, and a SQL editor sidebar schema browser. The schema editor is accessed through the Plan/Issue flow when editing database change specifications, and the ER diagram and schema pane are used in database detail and SQL editor views.
+
+## Issue Statement
+
+The SchemaEditorLite component suite (88 files, ~10,300 lines), the SchemaDiagram component suite (44 files, ~2,300 lines), and the SchemaPane sidebar (36+ tree node types, ~1,700 lines) are implemented entirely in Vue 3 with naive-ui dependencies, Vue provide/inject context, and Emittery event bus patterns that have no React equivalents. React pages that embed schema editing or visualization currently either use Vue bridge wrappers or import only leaf utilities (e.g., `getColumnDefaultValuePlaceholder`). No React implementation of the schema editor, diagram, or schema pane exists.
+
+## Current State
+
+### SchemaEditorLite (`frontend/src/components/SchemaEditorLite/`)
+
+- **Entry point**: `SchemaEditorLite.vue` (144 lines) — two-pane splitter (NSplit from naive-ui) with aside tree and editor panels
+- **88 files, ~10,300 lines total**
+- **Panels** (~1,300 lines): `DatabaseEditor.vue` (284), `TableEditor.vue` (480), `TableList.vue` (327), `ViewEditor.vue` (103), `FunctionEditor.vue` (70), `ProcedureEditor.vue` (70), `PreviewPane.vue` (144), `CommonCodeEditor.vue` (67)
+- **TableColumnEditor/** (~370 lines): `DataTypeCell.vue` (99), `DefaultValueCell.vue` (64), `ForeignKeyCell.vue` (100), `OperationCell.vue`, `ReorderCell.vue`, `SelectionCell.vue`
+- **IndexesEditor/** (133 lines), **PartitionsEditor/** (248 lines)
+- **Modals** (~1,069 lines): `ActionConfirmModal.vue` (59), `TableNameModal.vue` (177), `SchemaNameModal.vue` (105), `EditColumnForeignKeyModal.vue` (287), `ViewNameModal.vue` (142), `FunctionNameModal.vue` (150), `ProcedureNameModal.vue` (149)
+- **Aside/Tree** navigation: `Tree.vue` uses NTree from naive-ui with virtual scroll, context menus, and 10+ node checkbox variants (~390 lines)
+- **Context layer** (`context/`, ~1,267 lines): `provideSchemaEditorContext()` with Emittery event bus, `useTabs()` (131), `useEditStatus()` (237), `useSelection()` (628), `useScrollStatus()` (113)
+- **Algorithm layer** (`algorithm/`, ~979 lines): `diff-merge.ts` (790) handles nested metadata comparison/reconciliation, `rebuild.ts` (39), `apply.ts` (77)
+- **Types**: `types.ts` (107 lines) defines `EditTarget`, `TabContext` (database/table/view/procedure/function variants), `EditStatus`, `RolloutObject`
+- **Spec**: `spec.ts` exports engine-specific feature support predicates (`engineSupportsEditIndexes`, `engineSupportsEditTablePartitions`, etc.)
+- **Public API** (`index.ts`): exports types, common, spec, utils, context, edit, `ActionConfirmModal`, `TableColumnEditor`, and `SchemaEditorLite` default
+
+### SchemaDiagram (`frontend/src/components/SchemaDiagram/`)
+
+- **Entry point**: `SchemaDiagram.vue` (265 lines) — ER diagram with navigator, canvas, table nodes, FK lines
+- **44 files, ~2,300 lines total**
+- **Canvas**: SVG viewport with pan/zoom (`useDragCanvas`, `useFitView`, `useSetCenter`)
+- **ER layout**: `TableNode.vue` (228), `ForeignKeyLine.vue`, ELK auto-layout engine (`autoLayout/engines/elk.ts`, 70 lines)
+- **Navigator**: schema selector + table tree
+- **Geometry utilities** (~750 lines): 2D math for points, rectangles, line intersections
+
+### SchemaPane (`frontend/src/views/sql-editor/AsidePanel/SchemaPane/`)
+
+- **~1,735 lines total**
+- **36+ tree node types** in `TreeNode/`: `CommonNode.vue`, database/schema/table/view/procedure/function/index/trigger/sequence/partition nodes
+- **HoverPanel/**: `TableInfo.vue`, `ColumnInfo.vue`, `ViewInfo.vue`, etc.
+- **Utilities**: `tree.ts` (tree building from metadata), `click.ts` (routing), `hover-state.ts`, `actions.tsx` (context menu)
+
+### Integration points (Vue callers)
+
+- `Plan/components/StatementSection/SchemaEditorDrawer.vue` — wraps SchemaEditorLite in a drawer for plan SQL editing
+- `Plan/components/StatementSection/EditorView/EditorView.vue` — triggers SchemaEditorDrawer
+- `sql-editor/EditorPanel/Panels/TablesPanel/ColumnsTable.vue` — imports `DefaultValueCell`, `ForeignKeyCell`
+- `sql-editor/EditorPanel/Panels/ViewsPanel/ColumnsTable.vue` — imports `DefaultValueCell`
+- `sql-editor/EditorPanel/Panels/ExternalTablesPanel/ExternalTableColumnsTable.vue` — imports `DefaultValueCell`
+- `sql-editor/EditorPanel/DiagramPanel` — uses SchemaDiagram
+- `DatabaseDetail/SchemaDiagramButton.vue` — modal viewer for SchemaDiagram
+- `ColumnDataTable/index.vue` — imports `getColumnDefaultValuePlaceholder`
+- `sql-editor/AsidePanel/SchemaPane/HoverPanel/ColumnInfo.vue` — imports `getColumnDefaultValuePlaceholder`
+
+### React code that already touches schema utilities
+
+- `react/pages/project/database-detail/overview/DatabaseObjectExplorer.tsx` — imports `getColumnDefaultValuePlaceholder` from `SchemaEditorLite/utils/columnDefaultValue`
+
+### Existing React UI primitives available
+
+`frontend/src/react/components/ui/`: `dialog.tsx`, `sheet.tsx`, `alert-dialog.tsx`, `tabs.tsx`, `table.tsx`, `button.tsx`, `combobox.tsx`, `search-input.tsx`, `input.tsx`, `dropdown-menu.tsx`, `separator.tsx`, `tooltip.tsx`, `badge.tsx`, `switch.tsx`, `radio-group.tsx`, `textarea.tsx`
+
+### Key external dependencies in Vue implementation
+
+- **naive-ui**: NTree (virtual scroll), NSplit (resizable panes), NButton, NSelect, NDropdown, NModal
+- **Emittery**: event bus for context communication (6 event types)
+- **lodash-es**: `cloneDeep`, `isEqual`, `debounce`
+- **ELK**: graph layout for ER diagrams (`elkjs`)
+- **Monaco Editor**: SQL code editing (via wrapper)
+- **Proto-ES types**: `DatabaseMetadata`, `SchemaMetadata`, `TableMetadata`, `ColumnMetadata`, `ViewMetadata`, `ProcedureMetadata`, `FunctionMetadata`
+
+## Non-Goals
+
+- Rewriting the `algorithm/` layer (diff-merge, rebuild, apply) — these are pure TypeScript with no Vue dependencies and can be imported directly by React components
+- Rewriting `spec.ts` or `utils/` — these are pure TS functions, engine-specific predicates, and column default value helpers that work as-is
+- Rewriting `types.ts` — type definitions are framework-agnostic
+- Migrating the Plan/Issue pages themselves — the schema editor will be embedded as a React component but the parent Plan/Issue Vue pages will bridge to it
+- Migrating SQL editor views (TablesPanel, ViewsPanel, ExternalTablesPanel) — these are separate Vue surfaces with their own callers
+- Replacing ELK layout engine or Monaco editor integration — these are framework-agnostic libraries
+- Introducing new state management libraries (zustand, TanStack Query) unless a concrete problem arises
+- Changing schema editor behavior or adding new features during the migration
+- Migrating all Vue callers of the old component — Vue callers that are not themselves being migrated to React will continue using the Vue implementation until they are migrated
+
+## Open Questions
+
+1. Should the React SchemaEditorLite replace the Vue one globally, or should both coexist until all callers are migrated? (default: coexist — the React version will be used by React parents; Vue parents keep the Vue version until they are migrated)
+2. What replaces naive-ui's NTree with virtual scroll for the aside tree? (default: build a lightweight virtualized tree using `react-window` or a headless tree library; evaluate `@tanstack/react-virtual` as it is already a common pattern)
+3. What replaces naive-ui's NSplit for the resizable two-pane layout? (default: use a lightweight splitter like `react-resizable-panels` or build a minimal one with CSS resize)
+4. Should Emittery event bus be replaced with React context + callbacks, or kept as-is since it is framework-agnostic? (default: replace with React context + callbacks for idiomatic React; Emittery is framework-agnostic but the event-driven pattern is non-idiomatic in React)
+5. Should the SchemaDiagram and SchemaPane be migrated in the same effort or separately? (default: separately — they are distinct surfaces with different callers; the SchemaEditorLite is the primary target)
+
+## Scope
+
+**L** — This is a new subsystem migration spanning 88+ files and ~10,300 lines of interconnected Vue components, context providers, and event-driven state management. The schema editor has deep coupling between its tree navigation, tab management, edit tracking, selection state, and panel rendering. Multiple viable approaches exist for replacing Vue-specific patterns (provide/inject, Emittery, NTree virtual scroll, NSplit panes) with React equivalents. The algorithm/types/utils layers (~1,200 lines) can be reused directly, but the remaining ~9,100 lines of UI and state management require React reimplementation across ~70 component files.
diff --git a/docs/plans/2026-04-16-schema-editor-react-migration/design.md b/docs/plans/2026-04-16-schema-editor-react-migration/design.md
new file mode 100644
index 0000000000..581ff5d1b9
--- /dev/null
+++ b/docs/plans/2026-04-16-schema-editor-react-migration/design.md
@@ -0,0 +1,245 @@
+## References
+
+1. [Vue to React Migration: A Step-by-Step Approach](https://www.index.dev/blog/vue-to-react-migration-strategy) — Covers incremental migration strategies, coexistence patterns, and state management migration paths for large component suites.
+2. [Strategy and Tips for Migrating to React](https://brainhub.eu/library/migrating-to-react) — Practical patterns for complex UI migration including encapsulation strategy: wrap small interactive sections as React components, then progressively expand coverage.
+3. [DrawDB Architecture (DeepWiki)](https://deepwiki.com/drawdb-io/drawdb/1-overview) — Open-source React database schema editor using React Context + custom hooks for distributed state management, @dnd-kit for drag-and-drop, and modular component organization.
+4. [react-resizable-panels (GitHub)](https://github.com/bvaughn/react-resizable-panels) — Headless, unstyled resizable panel library for React. Exports PanelGroup, Panel, PanelResizeHandle. Supports horizontal/vertical, WAI-ARIA accessibility, imperative API, and layout persistence.
+5. [React Arborist (GitHub)](https://github.com/brimdata/react-arborist) — Headless virtualized tree component for React. Built on react-window. Supports drag-and-drop, keyboard navigation, ARIA, custom node renderers, and 10,000+ node performance.
+6. [Shadcn Resizable](https://www.shadcn.io/ui/resizable) — Shadcn wrapper around react-resizable-panels with Tailwind CSS styling and TypeScript support, providing a battle-tested drag mechanics pattern.
+7. [DrawDB Data Management (DeepWiki)](https://deepwiki.com/drawdb-io/drawdb/4-data-management) — DrawDB's schema editing state management: React Context + custom hooks for coordinated state updates, undo/redo history stack, and modular context providers per functional area.
+
+## Industry Baseline
+
+**State management for schema editors**: DrawDB (37k+ GitHub stars) uses React Context with custom hooks to distribute state across specialized providers (tables, relationships, areas, notes). Each functional area has its own context, and components access state through dedicated hooks. This avoids a single monolithic store while maintaining coordinated updates. (DrawDB Architecture, DrawDB Data Management)
+
+**Resizable split panes**: react-resizable-panels is the dominant solution (2025-2026), used by shadcn/ui's Resizable component. It is headless, accessible (WAI-ARIA), supports layout persistence, and provides imperative APIs for programmatic control. It replaces naive-ui's NSplit with a React-idiomatic API. (react-resizable-panels, Shadcn Resizable)
+
+**Virtualized tree navigation**: react-arborist provides a headless virtualized tree built on react-window. It handles 10,000+ nodes, supports keyboard navigation, drag-and-drop, inline rename, and custom node renderers. This maps directly to the NTree + virtual scroll pattern used in the Vue aside tree. (React Arborist)
+
+**Migration strategy**: Industry consensus for large Vue-to-React migrations (2025-2026) favors incremental, component-by-component migration with coexistence. Both sources recommend starting with leaf components, maintaining parallel systems during transition, and using intermediate layers for bridging. Complex editor interfaces should be wrapped as encapsulated React components, then progressively expanded. (Vue to React Migration, Strategy and Tips for Migrating to React)
+
+**Trade-offs and limitations**: Running two frameworks simultaneously adds build complexity and can cause DOM reconciliation conflicts if both try to manage the same DOM subtree. The incremental approach means the Vue version must be maintained until all callers are migrated, creating a temporary duplication cost. DrawDB's distributed context pattern works well for self-contained editors but requires careful coordination when embedding in a larger application with external state (e.g., Pinia stores).
+
+## Research Summary
+
+Key patterns across sources:
+
+1. **React Context replaces Vue provide/inject and Emittery**: All React schema editors studied use React Context for distributed state. DrawDB distributes state across multiple specialized context providers rather than a single store. This maps cleanly to the Vue SchemaEditorLite pattern where `provideSchemaEditorContext()` composes `useTabs`, `useEditStatus`, `useSelection`, and `useScrollStatus` — each becomes a React hook exposed through a single context provider.
+
+2. **Headless component libraries replace naive-ui**: react-resizable-panels replaces NSplit, react-arborist replaces NTree. Both are headless/unstyled, fitting the project's shadcn-style pattern where Base UI primitives are wrapped with CVA variants and Tailwind CSS. This avoids introducing a new opinionated component library.
+
+3. **Pure TS layers are reusable without modification**: The algorithm layer (diff-merge, rebuild, apply), types, specs, and utilities contain no Vue imports. They operate on protobuf metadata types and can be imported directly by React components, eliminating ~1,200 lines from the migration scope.
+
+4. **Incremental migration with coexistence is the correct approach**: The existing migration playbook already establishes this pattern. The React SchemaEditorLite will be a standalone component that Vue parents can embed (via a bridge wrapper if needed), while React parents use it directly. The Vue version continues to serve Vue callers until those callers are themselves migrated.
+
+5. **Event bus maps to callbacks and context dispatch**: The 6 Emittery events in the Vue implementation (`update:selected-rollout-objects`, `rebuild-tree`, `rebuild-edit-status`, `clear-tabs`, `refresh-preview`, `merge-metadata`) map to callback functions passed through React context or directly as props. React's unidirectional data flow replaces the bidirectional event pattern.
+
+## Design Goals
+
+1. **Feature parity with Vue SchemaEditorLite** — The React implementation must support all current editing capabilities: database/schema/table/view/procedure/function editing, column CRUD with type/default/FK cells, index editing, partition editing, tree navigation with context menus, tab management, edit status tracking, selection/rollout object tracking, and DDL preview. Verifiable: every panel type and modal in the Vue implementation has a React counterpart.
+
+2. **Zero regression in Vue callers** — Vue parents (SchemaEditorDrawer, EditorView) continue to work unchanged during and after migration. Verifiable: the Vue SchemaEditorLite component and its imports are not modified or deleted.
+
+3. **Reuse pure TS layers without forking** — The algorithm/, types.ts, spec.ts, and utils/ modules are imported directly by React components from their existing locations. No duplication or parallel implementations. Verifiable: React components import from `@/components/SchemaEditorLite/algorithm`, `@/components/SchemaEditorLite/types`, etc.
+
+4. **Follow established React patterns** — Use React Context (not zustand/redux), useVueState for store access, shadcn-style UI components, react-i18next, and the project's existing Sheet/Dialog/Tabs/Table primitives. Verifiable: no new state management libraries added; all UI primitives from `@/react/components/ui/`.
+
+5. **Incremental delivery** — The migration is structured so that each phase produces a usable, testable component. A partially-complete migration (e.g., table editor without partition editor) is useful on its own. Verifiable: each phase has defined entry and exit criteria.
+
+## Non-Goals
+
+- Rewriting the `algorithm/` layer (diff-merge, rebuild, apply) — pure TS, no Vue dependencies
+- Rewriting `spec.ts` or `utils/` — pure TS functions, engine-specific predicates
+- Rewriting `types.ts` — framework-agnostic type definitions
+- Migrating the Plan/Issue pages themselves
+- Migrating SQL editor views (TablesPanel, ViewsPanel, ExternalTablesPanel)
+- Replacing ELK layout engine or Monaco editor integration
+- Introducing new state management libraries (zustand, TanStack Query)
+- Changing schema editor behavior or adding new features during migration
+- Migrating all Vue callers — Vue callers keep the Vue version until they are migrated
+- Migrating SchemaDiagram or SchemaPane in this effort — these are distinct surfaces with different callers and should be separate migration efforts
+
+## Proposed Design
+
+### Architecture Overview
+
+The React SchemaEditorLite mirrors the Vue component's architecture: a context provider at the root, a two-pane layout with an aside tree on the left and tabbed editor panels on the right, and modal dialogs triggered by user actions. The key difference is replacing Vue-specific patterns (provide/inject, Emittery, naive-ui) with React equivalents (Context, callbacks, headless libraries).
+
+```
+SchemaEditorLite (React Context provider + react-resizable-panels)
+├── AsideTree (react-arborist with custom node renderers)
+│ ├── Node renderers (database, schema, table, view, procedure, function)
+│ ├── Node checkboxes (selection state)
+│ └── Context menu (dropdown-menu from ui/)
+├── EditorPanel (tab-based routing)
+│ ├── DatabaseEditor
+│ ├── TableEditor
+│ │ ├── TableColumnEditor (table from ui/ with editable cells)
+│ │ │ ├── DataTypeCell (combobox)
+│ │ │ ├── DefaultValueCell (input)
+│ │ │ ├── ForeignKeyCell (button + modal trigger)
+│ │ │ ├── OperationCell
+│ │ │ ├── ReorderCell (drag handle)
+│ │ │ └── SelectionCell (checkbox)
+│ │ ├── IndexesEditor
+│ │ └── PartitionsEditor
+│ ├── ViewEditor (Monaco wrapper)
+│ ├── ProcedureEditor (Monaco wrapper)
+│ ├── FunctionEditor (Monaco wrapper)
+│ └── PreviewPane (Monaco wrapper, DDL diff output)
+└── Modals
+ ├── TableNameModal (dialog)
+ ├── SchemaNameModal (dialog)
+ ├── EditColumnForeignKeyModal (sheet, wide)
+ ├── ViewNameModal (dialog)
+ ├── FunctionNameModal (dialog)
+ ├── ProcedureNameModal (dialog)
+ └── ActionConfirmModal (alert-dialog)
+```
+
+### State Management: React Context replacing provide/inject + Emittery
+
+The Vue `provideSchemaEditorContext` composes four sub-hooks (`useTabs`, `useEditStatus`, `useSelection`, `useScrollStatus`) and an Emittery event bus. The React equivalent uses a single context provider that exposes the same composed state through hooks.
+
+**Why React Context over zustand/TanStack**: The schema editor state is scoped to the editor instance, not global. React Context naturally scopes state to a component subtree, which matches the Vue provide/inject pattern exactly. Adding zustand would introduce global state for component-local concerns. (Traces to Design Goal 4: follow established React patterns)
+
+**Emittery replacement**: The 6 event types become callback functions on the context:
+
+| Emittery event | React equivalent |
+|---|---|
+| `update:selected-rollout-objects` | `onSelectedRolloutObjectsChange` prop (lifted to parent) |
+| `rebuild-tree` | `rebuildTree()` function on context, components call directly |
+| `rebuild-edit-status` | `rebuildEditStatus(resets)` function on context |
+| `clear-tabs` | `clearTabs()` function on context (part of tabs hook) |
+| `refresh-preview` | `refreshPreview()` function on context |
+| `merge-metadata` | `mergeMetadata(metadatas)` function on context |
+
+The context provider pattern:
+
+```
+SchemaEditorProvider (creates context with composed hooks)
+ └── provides: tabs, editStatus, selection, scrollStatus, callbacks
+ └── children consume via useSchemaEditorContext()
+```
+
+Each sub-hook (`useTabs`, `useEditStatus`, `useSelection`, `useScrollStatus`) is reimplemented as a React hook using `useState`/`useReducer`/`useRef`/`useMemo`/`useCallback`. The Vue `ref()` → React `useState()`, Vue `computed()` → React `useMemo()`, Vue `watch()` → React `useEffect()` mappings are direct.
+
+### Resizable Panes: react-resizable-panels replacing NSplit
+
+The Vue component uses `NSplit` with `min=0.15`, `max=0.4`, `default-size=0.25`. The React equivalent uses react-resizable-panels:
+
+```
+PanelGroup (direction="horizontal")
+ Panel (defaultSize=25, minSize=15, maxSize=40) → AsideTree
+ PanelResizeHandle
+ Panel (defaultSize=75) → EditorPanel
+```
+
+**Why react-resizable-panels over alternatives**: It is headless/unstyled (matches shadcn pattern), widely adopted, WAI-ARIA accessible, and the shadcn ecosystem already wraps it. No opinionated styles to override. (Traces to Design Goal 4)
+
+### Aside Tree: react-arborist replacing NTree
+
+The Vue aside uses naive-ui's NTree with virtual scroll for database/schema/table hierarchy navigation. react-arborist provides:
+
+- Virtualized rendering for large schemas (10,000+ nodes)
+- Custom node renderers (database, schema, table group, table, view, procedure, function nodes)
+- Keyboard navigation and ARIA
+- Selection state management
+
+**Context menu**: Implemented using `dropdown-menu` from `@/react/components/ui/` triggered on right-click, replacing naive-ui's NDropdown. The menu options (create table, rename, drop, etc.) are determined by node type, matching the Vue `context-menu.ts` logic.
+
+**Node checkboxes**: The 10+ node checkbox variants in Vue are simplified to a single `NodeCheckbox` component that receives the node's metadata type and delegates to the selection context. The checkbox variants in Vue exist because Vue template composition requires separate component files; React's JSX conditional rendering handles this in a single component.
+
+**Why react-arborist over building from scratch**: The Vue implementation wraps NTree which provides virtualization, keyboard nav, and node rendering. react-arborist provides the same feature set as a headless component with custom renderers, avoiding reimplementing virtual scroll. (Traces to Design Goal 1: feature parity)
+
+### Tab Management
+
+The Vue `useTabs` hook manages a `Map<string, TabContext>` with current tab tracking. The React equivalent is a `useReducer` with actions for `ADD_TAB`, `CLOSE_TAB`, `SET_CURRENT_TAB`, `CLEAR_TABS`. The tab list renders using the `Tabs` component from `@/react/components/ui/tabs`.
+
+Tab-to-panel routing: The `EditorPanel` reads `currentTab.type` from context and renders the corresponding panel component (DatabaseEditor, TableEditor, ViewEditor, ProcedureEditor, FunctionEditor).
+
+### Editor Panels
+
+Each panel is a direct port of its Vue counterpart:
+
+- **TableEditor**: Multi-mode tabs (Columns, Indexes, Partitions) using `Tabs` from ui/. The column editor is the most complex sub-component, rendering an editable table with custom cell renderers for each column property.
+- **TableColumnEditor**: Uses `Table` from `@/react/components/ui/table` with inline-editable cells. Each cell type (DataTypeCell, DefaultValueCell, ForeignKeyCell, OperationCell, ReorderCell, SelectionCell) becomes a React component. The `DataTypeCell` uses `Combobox` for type suggestions. Drag-to-reorder uses HTML5 drag-and-drop or a lightweight drag library.
+- **IndexesEditor / PartitionsEditor**: Simpler table-based editors, direct ports.
+- **ViewEditor / ProcedureEditor / FunctionEditor**: Wrap the Monaco editor component from `@/react/components/monaco/`.
+- **PreviewPane**: Read-only Monaco editor showing generated DDL via `generateDiffDDL()` from the reused algorithm layer.
+
+### Modals
+
+Modals map to existing React UI primitives:
+
+| Vue Modal | React Component | UI Primitive |
+|---|---|---|
+| ActionConfirmModal | ActionConfirmDialog | `AlertDialog` |
+| TableNameModal | TableNameDialog | `Dialog` |
+| SchemaNameModal | SchemaNameDialog | `Dialog` |
+| EditColumnForeignKeyModal | EditColumnForeignKeySheet | `Sheet` (wide) |
+| ViewNameModal | ViewNameDialog | `Dialog` |
+| FunctionNameModal | FunctionNameDialog | `Dialog` |
+| ProcedureNameModal | ProcedureNameDialog | `Dialog` |
+
+The EditColumnForeignKeyModal is the only one that warrants a Sheet (wide) because it contains a multi-field form with table/column selectors. The others are single-field dialogs (name input + confirm/cancel).
+
+### Pure TS Layer Reuse
+
+The following modules are imported directly by React components without modification:
+
+- `algorithm/diff-merge.ts` — metadata comparison and reconciliation
+- `algorithm/rebuild.ts` — rebuild metadata from edit operations
+- `algorithm/apply.ts` — apply changes to in-memory metadata
+- `types.ts` — EditTarget, TabContext, RolloutObject, EditStatus
+- `spec.ts` — engine feature support predicates
+- `utils/columnDefaultValue.ts` — default value placeholder logic
+- `utils/metadata.ts` — metadata transformation helpers
+- `common.ts` — `generateDiffDDL()` RPC call
+
+This preserves ~1,200 lines of tested logic and ensures DDL generation behavior is identical between Vue and React implementations.
+
+### Public API and Bridge
+
+The React SchemaEditorLite exposes the same interface as the Vue version:
+
+- Props: `project`, `readonly`, `selectedRolloutObjects`, `targets`, `loading`, `hidePreview`
+- Callbacks: `onSelectedRolloutObjectsChange`, `onIsEditingChange`
+- Imperative handle (via `useImperativeHandle`/`forwardRef`): `applyMetadataEdit()`, `refreshPreview()`, `isDirty`
+
+For Vue parents that need to embed the React version (future migration step), a thin Vue wrapper component can mount the React component via `createRoot`. However, this is not required in the initial migration — the React version will be consumed by React parents only, and Vue parents continue using the Vue version. (Traces to Design Goal 2: zero regression, and Non-Goal: not migrating all Vue callers)
+
+### Migration Phases
+
+**Phase 1: Foundation** (~2,000 lines)
+- React context provider (replacing provideSchemaEditorContext + Emittery)
+- useTabs, useEditStatus, useSelection, useScrollStatus hooks
+- SchemaEditorLite shell with react-resizable-panels
+- Entry: types.ts, spec.ts, utils/, algorithm/ confirmed importable from React
+- Exit: empty editor renders with resizable panes, context available to children
+
+**Phase 2: Aside Tree** (~1,500 lines)
+- react-arborist integration with custom node renderers
+- Context menu with create/rename/drop actions
+- Node checkbox selection (single component with type-based rendering)
+- Search/filter functionality
+- Exit: tree navigates database metadata, context menu triggers stubs
+
+**Phase 3: Core Editors** (~2,500 lines)
+- Tab container with type-based routing
+- TableEditor with column editor (DataTypeCell, DefaultValueCell, ForeignKeyCell, OperationCell, ReorderCell, SelectionCell)
+- DatabaseEditor (schema selector, table creation trigger)
+- Exit: table columns editable, new tables creatable
+
+**Phase 4: Extended Editors** (~1,500 lines)
+- IndexesEditor, PartitionsEditor
+- ViewEditor, ProcedureEditor, FunctionEditor (Monaco wrappers)
+- PreviewPane (DDL diff display)
+- Exit: all editor panel types functional
+
+**Phase 5: Modals and Polish** (~1,500 lines)
+- All 7 modal dialogs
+- Edit status indicators (created/updated/dropped visual markers)
+- Scroll position preservation
+- Integration testing with `applyMetadataEdit` + `generateDiffDDL`
+- Exit: full feature parity verified against Vue implementation
diff --git a/docs/plans/2026-04-16-schema-editor-react-migration/plan.md b/docs/plans/2026-04-16-schema-editor-react-migration/plan.md
new file mode 100644
index 0000000000..8e9ea765fd
--- /dev/null
+++ b/docs/plans/2026-04-16-schema-editor-react-migration/plan.md
@@ -0,0 +1,537 @@
+## Task List
+
+T1: Install dependencies [S] — T2: Create React context types and provider [L] — T3: Implement useTabs hook [M] — T4: Implement useEditStatus hook [M] — T5: Implement useSelection hook [L] — T6: Implement useScrollStatus hook [M] — T7: Create SchemaEditorLite shell with resizable panels [M] — T8: Wire algorithm layer to React context [M] — T9: Create tree node types and builder [L] — T10: Create AsideTree with react-arborist [L] — T11: Implement context menu [M] — T12: Implement node prefix icons and node checkbox [M] — T13: Create TabsContainer and EditorPanel routing [M] — T14: Create DatabaseEditor panel [L] — T15: Create TableEditor panel shell [M] — T16: Create TableColumnEditor with cell components [L] — T17: Create TableList component [M] — T18: Create IndexesEditor [M] — T19: Create PartitionsEditor [M] — T20: Create ViewEditor, ProcedureEditor, FunctionEditor [M] — T21: Create PreviewPane [M] — T22: Create TableNameDialog and SchemaNameDialog [M] — T23: Create ViewNameDialog, FunctionNameDialog, ProcedureNameDialog [M] — T24: Create EditColumnForeignKeySheet [L] — T25: Create ActionConfirmDialog [S] — T26: Wire imperative handle and public API [M] — T27: Add i18n keys for React schema editor [M] — T28: Final validation [M]
+
+---
+
+### T1: Install dependencies [S]
+
+**Objective**: Add react-resizable-panels and react-arborist to the frontend package. Traces to Design Goal 4 (follow established React patterns — headless libraries matching shadcn style).
+**Files**: `frontend/package.json`
+**Implementation**: Run `pnpm --dir frontend add react-resizable-panels react-arborist`
+**Validation**: `cat frontend/package.json | grep -E "react-resizable-panels|react-arborist"` — both packages listed
+
+---
+
+### T2: Create React context types and provider [L]
+
+**Objective**: Create the React SchemaEditorContext that replaces Vue's provide/inject + Emittery. This is the central state container consumed by all child components. Traces to Design Goal 4.
+**Size**: L (core architecture, many type definitions, context composition)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/context.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/types.ts`
+**Implementation**:
+1. In `types.ts`: Define `SchemaEditorContextValue` interface composing all sub-hook return types. Define `SchemaEditorProps` (project, readonly, selectedRolloutObjects, targets, loading, hidePreview, onSelectedRolloutObjectsChange, onIsEditingChange). Re-export `EditTarget`, `TabContext`, `RolloutObject`, `EditStatus` from `@/components/SchemaEditorLite/types`.
+2. In `context.tsx`: Create React context via `createContext<SchemaEditorContextValue>`. Create `SchemaEditorProvider` component that composes `useTabs()`, `useEditStatus()`, `useSelection()`, `useScrollStatus()` hooks and provides the combined value. Create `useSchemaEditorContext()` hook that calls `useContext()`. Define callback interfaces that replace Emittery events: `rebuildTree(openFirstChild)`, `rebuildEditStatus(resets)`, `clearTabs()`, `refreshPreview()`, `mergeMetadata(metadatas)`.
+**Boundaries**: Do NOT implement the sub-hooks themselves (T3-T6). Use stub/placeholder types for now.
+**Dependencies**: None
+**Expected Outcome**: Context provider and consumer hook exist, type-check passes
+**Validation**: `pnpm --dir frontend type-check` — no errors in new files
+
+---
+
+### T3: Implement useTabs hook [M]
+
+**Objective**: Port Vue `useTabs` (context/tabs.ts, 131 lines) to React. Manages tab CRUD and current tab tracking.
+**Size**: M (single file, moderate state logic)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/useTabs.ts`
+**Implementation**:
+1. State: `tabMap` via `useRef<Map<string, TabContext>>`, `currentTabId` via `useState<string>`, `tabList` via `useMemo` derived from tabMap, `currentTab` via `useMemo` looking up tabMap by currentTabId.
+2. Functions: `addTab(coreTab, setAsCurrentTab?)` — reuses existing tab if found (via `findTab`), otherwise creates new with UUID. `setCurrentTab(id)` — validates id exists. `closeTab(id)` — removes tab, selects next/prev. `findTab(target)` — matches by type + database + schema/table/view/procedure/function names. `clearTabs()` — clears map and currentTabId.
+3. Use `useCallback` for all functions. Use `requestAnimationFrame` for deferred currentTabId assignment (matching Vue behavior).
+**Boundaries**: Does NOT render any UI. Pure state hook.
+**Dependencies**: T2 (types)
+**Expected Outcome**: Hook returns `TabsContext` matching the interface defined in T2
+**Validation**: `pnpm --dir frontend type-check` — no errors
+
+---
+
+### T4: Implement useEditStatus hook [M]
+
+**Objective**: Port Vue `useEditStatus` (context/edit.ts, 237 lines) to React. Tracks which database objects are created/updated/dropped.
+**Size**: M (single file, map-based state with derived queries)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/useEditStatus.ts`
+**Implementation**:
+1. State: `dirtyPaths` via `useRef<Map<string, EditStatus>>` with a `version` counter via `useState` to trigger re-renders on mutation.
+2. Functions: `markEditStatus(database, metadata, status)`, `markEditStatusByKey(key, status)`, `getEditStatusByKey(key)`, `removeEditStatus(database, metadata, recursive)`, `clearEditStatus()`.
+3. Derived queries: `getSchemaStatus`, `getTableStatus`, `getColumnStatus`, `getPartitionStatus`, `getProcedureStatus`, `getFunctionStatus`, `getViewStatus` — check if resource or any children are dirty.
+4. `replaceTableName(database, metadata, newName)` — updates all paths matching old table key.
+5. `isDirty` via `useMemo` — true if dirtyPaths is non-empty.
+6. Import `keyForResource`, `keyForResourceName` from `@/components/SchemaEditorLite/context/common` (pure TS, no Vue deps).
+**Boundaries**: Pure state hook, no UI.
+**Dependencies**: T2
+**Expected Outcome**: Hook returns `EditStatusContext` matching interface
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T5: Implement useSelection hook [L]
+
+**Objective**: Port Vue `useSelection` (context/selection.ts, 628 lines) to React. Manages rollout object selection state for tables, columns, views, procedures, functions.
+**Size**: L (628 lines of selection logic with checked/indeterminate states for 5 resource types)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/useSelection.ts`
+**Implementation**:
+1. Accept `selectedRolloutObjects` and `onSelectedRolloutObjectsChange` as parameters (lifted state pattern replacing Emittery event).
+2. `selectionEnabled` = `selectedRolloutObjects !== undefined`.
+3. `selectedRolloutObjectMap` via `useMemo` — Map from key to RolloutObject.
+4. For each resource type (table, column, view, procedure, function): `get{Type}SelectionState(db, metadata)` → `{ checked, indeterminate }`, `update{Type}Selection(db, metadata, on)`, `getAll{Type}sSelectionState(db, metadata, items)`, `updateAll{Type}sSelection(db, metadata, items, on)`.
+5. Table selection includes all columns. Column selection ensures parent table is selected. Indeterminate = some-but-not-all children selected.
+6. All update functions call `onSelectedRolloutObjectsChange(updatedArray)`.
+7. Import `keyForResource` from `@/components/SchemaEditorLite/context/common`.
+**Boundaries**: Pure state hook. Does NOT render checkboxes.
+**Dependencies**: T2
+**Expected Outcome**: Hook returns `SelectionContext` matching interface
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T6: Implement useScrollStatus hook [M]
+
+**Objective**: Port Vue `useScrollStatus` (context/scroll.ts, 113 lines) to React. Queues pending scroll-to-table and scroll-to-column requests for consumption by panels.
+**Size**: M (2 files — hook + consume pattern)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/useScrollStatus.ts`
+**Implementation**:
+1. State: `pendingScrollToTable` via `useState`, `pendingScrollToColumn` via `useState`.
+2. Functions: `queuePendingScrollToTable(params)` — wraps in `requestAnimationFrame`. `queuePendingScrollToColumn(params)`.
+3. Consumer hooks: `useConsumePendingScrollToTable(condition, fn)` — `useEffect` that watches pendingScrollToTable, checks if condition matches (db + schema), calls fn and clears pending. Same for `useConsumePendingScrollToColumn`.
+4. Rich metadata types: `RichSchemaMetadata`, `RichTableMetadata`, `RichColumnMetadata`, `RichMetadataWithDB<T>` — port from Vue types.
+**Boundaries**: Pure state hook.
+**Dependencies**: T2
+**Expected Outcome**: Hook returns `ScrollStatusContext`
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T7: Create SchemaEditorLite shell with resizable panels [M]
+
+**Objective**: Create the top-level React SchemaEditorLite component with resizable two-pane layout. Traces to Design Goal 5 (incremental delivery — Phase 1 exit criterion).
+**Size**: M (root component, react-resizable-panels integration)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/SchemaEditorLite.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/index.ts`
+**Implementation**:
+1. In `SchemaEditorLite.tsx`: Accept `SchemaEditorProps`. Render `SchemaEditorProvider` wrapping `PanelGroup` (horizontal) with two `Panel`s separated by `PanelResizeHandle`. Left panel: defaultSize=25, minSize=15, maxSize=40 → placeholder for AsideTree. Right panel: defaultSize=75 → placeholder for EditorPanel. Show loading spinner when `loading` or targets empty. Use `forwardRef` + `useImperativeHandle` to expose `applyMetadataEdit`, `refreshPreview`, `isDirty` (stubs initially).
+2. In `index.ts`: Re-export component and types.
+**Boundaries**: Aside and Editor panels are placeholders. Imperative handle methods are stubs.
+**Dependencies**: T1 (react-resizable-panels), T2 (context)
+**Expected Outcome**: Component renders two resizable panes with placeholder content
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T8: Wire algorithm layer to React context [M]
+
+**Objective**: Create React-compatible wrappers for `useRebuildMetadataEdit` and `useApplyMetadataEdit` that work with the React context interface instead of the Vue SchemaEditorContext.
+**Size**: M (2 thin wrapper functions + interface adapter)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/useAlgorithm.ts`
+**Implementation**:
+1. `useRebuildMetadataEdit(context)`: Takes React context. Calls `clearEditStatus()`, constructs `DiffMerge` with a thin adapter `{ markEditStatusByKey: context.markEditStatusByKey }`, calls `dm.merge()`. Then via `setTimeout(0)` (replacing Vue `nextTick`): calls `context.clearTabs()` and/or `context.rebuildTree()` based on resets parameter.
+2. `useApplyMetadataEdit(context)`: Takes React context. Returns `applyMetadataEdit(database, metadata)` that clones metadata and filters out dropped schemas/tables/columns/views/procedures/functions using context status getters.
+3. The `DiffMerge` class from `@/components/SchemaEditorLite/algorithm/diff-merge` accepts `context` parameter but only uses `markEditStatusByKey`. Create a `DiffMergeContext` interface type with just `{ markEditStatusByKey: (key: string, status: EditStatus) => void }` and cast the React context to satisfy it.
+**Boundaries**: Does NOT modify the Vue algorithm files. Creates new React-side wrappers.
+**Dependencies**: T2, T4 (useEditStatus)
+**Expected Outcome**: `useAlgorithm(context)` returns `{ rebuildMetadataEdit, applyMetadataEdit }`
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T9: Create tree node types and builder [L]
+
+**Objective**: Port the tree node type system and `useBuildTree()` from Vue `Aside/common.ts` (~420 lines) to React. This builds the hierarchical tree data from database metadata.
+**Size**: L (complex type hierarchy, recursive tree building, key generation)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Aside/tree-builder.ts`
+**Implementation**:
+1. Define TreeNode union type: `TreeNodeForInstance`, `TreeNodeForDatabase`, `TreeNodeForSchema`, `TreeNodeForTable`, `TreeNodeForColumn`, `TreeNodeForView`, `TreeNodeForProcedure`, `TreeNodeForFunction`, `TreeNodeForGroup<T>`, `TreeNodeForPlaceholder<T>`. Each extends a base `{ key: string; label: string; isLeaf: boolean; children?: TreeNode[] }`. Adapt from naive-ui's `TreeOption` to a framework-agnostic interface compatible with react-arborist's node data.
+2. `buildTree(targets: EditTarget[])`: Maps `EditTarget[]` → `TreeNode[]` hierarchy. Groups by instance. For each database, iterates schemas. For single-schema engines (MySQL/TiDB), skips schema nodes. Creates group nodes (table, view, procedure, function) under each schema. Creates leaf nodes under each group. Handles placeholder nodes for empty groups.
+3. Uses `keyForResource`/`keyForResourceName` from `@/components/SchemaEditorLite/context/common`.
+4. Returns `{ tree: TreeNode[]; nodeMap: Map<string, TreeNode> }`.
+**Boundaries**: Pure data transformation, no UI, no React hooks.
+**Dependencies**: T2 (types)
+**Expected Outcome**: `buildTree()` generates correct hierarchy from EditTarget metadata
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T10: Create AsideTree with react-arborist [L]
+
+**Objective**: Create the aside tree navigation panel using react-arborist for virtualized rendering. Port from Vue `Aside/Tree.vue` (~680 lines).
+**Size**: L (react-arborist integration, custom renderers, search, tree state management)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Aside/AsideTree.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Aside/index.ts`
+**Implementation**:
+1. State: `searchPattern` via `useState`, debounced via `useMemo`+`debounce`. Tree data via `useMemo` calling `buildTree(targets)`. `treeRef` via `useRef` for react-arborist's Tree ref.
+2. Render: `SearchInput` at top (from ui/). `Tree` from react-arborist with `data={treeData}`, `rowHeight={28}`, custom `renderRow`. Node renderer switches on node type for label styling (green=created, yellow=updated, red+strikethrough=dropped).
+3. Click handling: Schema/group → expand + open database tab. Table → open table tab. View/Procedure/Function → open respective tab. Column → open parent table + queue scroll.
+4. Listen for `rebuildTree` callback from context to trigger tree data rebuild.
+5. Search: Debounced 500ms, fetches filtered metadata from server via `dbSchemaStore.getOrFetchDatabaseMetadata()`, merges via `mergeMetadata()`, triggers rebuild.
+**Boundaries**: Context menu is T11, node checkboxes are T12.
+**Dependencies**: T1 (react-arborist), T2, T3 (tabs), T9 (tree builder)
+**Expected Outcome**: Tree renders database metadata hierarchy with click-to-navigate
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T11: Implement context menu [M]
+
+**Objective**: Port context menu logic from Vue `Aside/context-menu.ts` (~200 lines) to React.
+**Size**: M (context menu options + handlers, DropdownMenu integration)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Aside/useContextMenu.ts`
+- Modify: `frontend/src/react/components/SchemaEditorLite/Aside/AsideTree.tsx`
+**Implementation**:
+1. In `useContextMenu.ts`: Hook returning `{ menuState, menuOptions, showMenu(e, node), handleSelect(key) }`. `menuState` = `{ show, x, y, node }`. `menuOptions` computed from node type: database → [Create Schema]; schema → [Drop/Restore]; table group → [Create Table]; table → [Rename, Drop/Restore]; view/procedure/function → [Drop/Restore]. Returns action callbacks that the tree component wires to modal state.
+2. In `AsideTree.tsx`: Add `DropdownMenu` from ui/ rendered at `menuState.x, menuState.y` when `menuState.show`. Wire `onContextMenu` on tree nodes to `showMenu()`. Wire menu items to `handleSelect()` which dispatches to callbacks (openTableNameModal, openSchemaNameModal, markDropped, markRestored).
+**Boundaries**: Modals themselves are T22-T25.
+**Dependencies**: T10
+**Expected Outcome**: Right-click on tree nodes shows context menu with correct options
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T12: Implement node prefix icons and node checkbox [M]
+
+**Objective**: Port NodePrefix.vue and the 10+ NodeCheckbox variants to React as unified components.
+**Size**: M (icon mapping + single checkbox component)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Aside/NodePrefix.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Aside/NodeCheckbox.tsx`
+**Implementation**:
+1. `NodePrefix`: Renders icon based on node type (DatabaseIcon, TableIcon, ViewIcon, etc.). For column nodes: PrimaryKeyIcon if in PK, IndexIcon if indexed. Conditionally renders `NodeCheckbox` if `selectionEnabled` from context.
+2. `NodeCheckbox`: Single component replacing 10+ Vue variants. Accepts `node: TreeNode`. Switches on node type to call appropriate selection context methods: for table → `getTableSelectionState`/`updateTableSelection`; for column → `getColumnSelectionState`/`updateColumnSelection`; for view/procedure/function → similar. For group nodes → `getAll{Type}sSelectionState`/`updateAll{Type}sSelection`. For schema → aggregate of all child groups.
+**Boundaries**: Does NOT handle selection state itself (delegates to context from T5).
+**Dependencies**: T5 (selection), T10 (tree)
+**Expected Outcome**: Tree nodes show correct icons and functional checkboxes
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T13: Create TabsContainer and EditorPanel routing [M]
+
+**Objective**: Port Editor.vue (68 lines) and TabsContainer.vue (179 lines) to React. Provides tab bar and panel routing.
+**Size**: M (2 components, tab rendering + type-based routing)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/EditorPanel.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/TabsContainer.tsx`
+**Implementation**:
+1. `TabsContainer`: Horizontal scrolling tab bar. Each tab shows icon + name (truncated via `EllipsisText`) + close button. Tab colors based on edit status: dropped=red+line-through, created=green, updated=yellow. Click → `setCurrentTab()`. Close button → `closeTab()`. Auto-scroll active tab into view via `useEffect` + `scrollIntoView`.
+2. `EditorPanel`: Renders `TabsContainer` at top. Below, switches on `currentTab.type`: "database" → `DatabaseEditor`, "table" → `TableEditor`, "view" → `ViewEditor`, "procedure" → `ProcedureEditor`, "function" → `FunctionEditor`. Uses `key={currentTab.id}` to force remount on tab switch. Shows empty state when no tab selected.
+**Boundaries**: Panel components themselves are T14-T21 (use placeholders initially).
+**Dependencies**: T2, T3 (tabs), T4 (edit status)
+**Expected Outcome**: Tab bar renders with click/close, panel area routes to correct component
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T14: Create DatabaseEditor panel [L]
+
+**Objective**: Port DatabaseEditor.vue (284 lines) to React. Provides schema selector, table list, and create-table trigger.
+**Size**: L (schema selector, sub-tab switching, table list integration)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/DatabaseEditor.tsx`
+**Implementation**:
+1. Props: `db`, `database`, `selectedSchemaName`, `onSelectedSchemaNameChange`, `searchPattern`.
+2. State: `selectedSubTab` ("table-list" | "schema-diagram"), `tableNameModalContext`.
+3. Schema selector: `Combobox` (from ui/) visible only for PostgreSQL (`hasSchemaProperty(engine)`). Auto-select first schema if current is invalid via `useEffect`.
+4. Toolbar: "Create Table" button (disabled if readonly or schema dropped). Selection summary badge if `selectionEnabled`.
+5. Content: Renders `TableList` component when sub-tab is "table-list". Schema diagram disabled for now (non-goal).
+6. Handlers: `handleCreateNewTable()` → sets `tableNameModalContext`. `tryEditTable(table)` → `addTab()` with table tab.
+**Boundaries**: Schema diagram tab shows "coming soon" or is hidden. TableNameDialog rendered conditionally from modal context.
+**Dependencies**: T2, T3, T4, T17 (TableList)
+**Expected Outcome**: Database panel shows schema selector (PG), table list, create button
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T15: Create TableEditor panel shell [M]
+
+**Objective**: Port TableEditor.vue (480 lines) to React. Provides the multi-mode editor (Columns/Indexes/Partitions) with toolbar and handlers.
+**Size**: M (mode switching, toolbar buttons, handler orchestration)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableEditor.tsx`
+**Implementation**:
+1. Props: `db`, `database`, `schema`, `table`, `searchPattern`.
+2. State: `mode` ("COLUMNS" | "INDEXES" | "PARTITIONS"), `showEditColumnForeignKeyModal`, `editForeignKeyContext`.
+3. Computed: `engine`, `disableChangeTable`, `allowChangePrimaryKeys`, `allowReorderColumns`, `showIndexes` (engine supports), `showPartitions` (engine supports).
+4. Toolbar: Mode buttons (Columns/Indexes/Partitions), "Add Column"/"Add Index"/"Add Partition" buttons, selection summary badge.
+5. Content: Switch on mode → `TableColumnEditor`, `IndexesEditor`, `PartitionsEditor`.
+6. Handlers: `handleAddColumn()` — create empty ColumnMetadata, push to table.columns, mark created, rebuild tree, queue scroll. `handleAddIndex/Partition()` — similar. `handleEditColumnForeignKey(column, fk)` — open FK modal. `markTableStatus()` — status management.
+7. Footer: `PreviewPane` rendered below editor.
+**Boundaries**: Cell components are T16. Index/Partition editors are T18-T19.
+**Dependencies**: T2, T3, T4, T6
+**Expected Outcome**: Table editor shell renders with mode switching and add buttons
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T16: Create TableColumnEditor with cell components [L]
+
+**Objective**: Port TableColumnEditor.vue (~370 lines) and its 6 cell components to React. This is the most complex editor sub-component.
+**Size**: L (editable table with 10+ columns, custom cell renderers, virtual scroll)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/TableColumnEditor.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/DataTypeCell.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/DefaultValueCell.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/ForeignKeyCell.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/OperationCell.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/ReorderCell.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/SelectionCell.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/index.ts`
+**Implementation**:
+1. `TableColumnEditor`: Renders a `Table` (from ui/) with columns: Selection (checkbox), Reorder (up/down), Name (inline input), Type (DataTypeCell), Default (DefaultValueCell), On Update (MySQL only), Comment, Not Null (checkbox), Primary Key (checkbox), Foreign Key (ForeignKeyCell), Operations (OperationCell). Columns conditionally visible based on engine/readonly/selection state.
+2. `DataTypeCell`: `Combobox` with type suggestions from `getDataTypeSuggestionList(engine)`.
+3. `DefaultValueCell`: Dropdown for null/expression/value + input. Uses `getColumnDefaultValuePlaceholder()`.
+4. `ForeignKeyCell`: Display FK reference as "schema.table(column)" link + edit button. Emits `onForeignKeyEdit`/`onForeignKeyClick`.
+5. `OperationCell`: Drop button (or Restore if dropped). Prevents dropping last column.
+6. `ReorderCell`: Up/down arrow buttons using `arraySwap()`.
+7. `SelectionCell`: Checkbox using column selection from context.
+8. PK detection: Find index with `primary=true`, check if column in `pk.expressions`.
+**Boundaries**: Does NOT implement virtual scroll in first pass (standard table). Can add virtualization later.
+**Dependencies**: T2, T4, T5, T6, T15
+**Expected Outcome**: Column editor renders editable table with all cell types
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T17: Create TableList component [M]
+
+**Objective**: Port TableList.vue (327 lines) with NameCell, OperationCell, SelectionCell to React.
+**Size**: M (table with 3 custom cells)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableList/TableList.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/TableList/index.ts`
+**Implementation**:
+1. `TableList`: Renders `Table` from ui/ with columns: Selection (checkbox for table), Name (clickable, edit-status-colored), Engine (MySQL), Comment, Collation, Operations (drop/restore).
+2. Props: `db`, `database`, `schema`, `tables`, `searchPattern`, `onEditTable(table)`, `onEditColumn(column)`.
+3. Filter tables by searchPattern. Row styling: green=created, yellow=updated, red=dropped.
+4. Selection: All-tables checkbox header, per-table checkboxes. Uses `getAllTablesSelectionState`/`updateAllTablesSelection` from selection context.
+5. NameCell: Clickable → calls `onEditTable(table)`. Shows status color.
+6. OperationCell: Drop/restore with status guards.
+**Boundaries**: Reuses selection context from T5.
+**Dependencies**: T2, T4, T5, T14
+**Expected Outcome**: Table list renders with selection, click-to-edit, drop/restore
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T18: Create IndexesEditor [M]
+
+**Objective**: Port IndexesEditor.vue (133 lines) with ColumnsCell and OperationCell to React.
+**Size**: M (table with custom cells for index definition)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/IndexesEditor/IndexesEditor.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/IndexesEditor/index.ts`
+**Implementation**:
+1. `IndexesEditor`: Table with columns: Name (input), Columns (multi-select from table columns), Unique (checkbox), Primary (checkbox, read-only), Comment, Operations.
+2. Props: `db`, `database`, `schema`, `table`, `readonly`.
+3. ColumnsCell: `Combobox` (multi) selecting from `table.columns[].name`.
+4. OperationCell: Drop/restore based on edit status.
+5. Index mutations: Direct modification of `table.indexes[]` array + `markEditStatus`.
+**Boundaries**: Pure editor, no modal interactions.
+**Dependencies**: T2, T4, T15
+**Expected Outcome**: Index editor renders with editable fields
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T19: Create PartitionsEditor [M]
+
+**Objective**: Port PartitionsEditor.vue (248 lines) with cell components to React.
+**Size**: M (table with 5 custom cells)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/PartitionsEditor/PartitionsEditor.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/PartitionsEditor/index.ts`
+**Implementation**:
+1. Table columns: Name (input), Type (select: RANGE/LIST/HASH), Expression (input), Value (input), Operations.
+2. Props: `db`, `database`, `schema`, `table`, `readonly`.
+3. Type defaults: New partitions copy type from first existing partition.
+4. OperationCell: Drop/restore.
+5. Direct mutation of `table.partitions[]` + `markEditStatus`.
+**Boundaries**: Supports MySQL/TiDB partition types only (per spec.ts).
+**Dependencies**: T2, T4, T15
+**Expected Outcome**: Partition editor renders with editable fields
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T20: Create ViewEditor, ProcedureEditor, FunctionEditor [M]
+
+**Objective**: Port ViewEditor.vue (103 lines), ProcedureEditor.vue (70 lines), FunctionEditor.vue (70 lines) to React. All are similar: Monaco editor for SQL definition.
+**Size**: M (3 similar components wrapping Monaco)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/ViewEditor.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/ProcedureEditor.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/FunctionEditor.tsx`
+**Implementation**:
+1. Each component: Props from tab context (db, database, schema, view/procedure/function). Renders `MonacoEditor` (from `@/react/components/monaco/`) with SQL content. On change → update metadata definition + `markEditStatus("updated")`. Readonly mode from context.
+2. ViewEditor: Edits `view.definition`.
+3. ProcedureEditor: Edits `procedure.definition`.
+4. FunctionEditor: Edits `function.definition`.
+**Boundaries**: No additional UI beyond Monaco editor.
+**Dependencies**: T2, T4, T13
+**Expected Outcome**: SQL editors render and track changes
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T21: Create PreviewPane [M]
+
+**Objective**: Port PreviewPane.vue (144 lines) to React. Shows generated DDL diff in a read-only Monaco editor.
+**Size**: M (Monaco wrapper + DDL generation call)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Panels/PreviewPane.tsx`
+**Implementation**:
+1. Props: `db`, `database`, `schema`, `table`.
+2. Computes "mocked" metadata: clone table, filter out dropped columns.
+3. Calls `generateDiffDDL()` from `@/components/SchemaEditorLite/common` with baseline vs mocked metadata.
+4. Renders `ReadonlyMonaco` (from `@/react/components/monaco/`) with SQL dialect matching engine.
+5. Refresh: listens for `refreshPreview` callback from context via `useEffect`.
+6. Show/hide toggle via `hidePreview` from context.
+**Boundaries**: Does NOT modify metadata.
+**Dependencies**: T2, T13
+**Expected Outcome**: Preview pane shows generated DDL
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T22: Create TableNameDialog and SchemaNameDialog [M]
+
+**Objective**: Port TableNameModal.vue (177 lines) and SchemaNameModal.vue (105 lines) to React using Dialog from ui/.
+**Size**: M (2 dialog forms with validation)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Modals/TableNameDialog.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Modals/SchemaNameDialog.tsx`
+**Implementation**:
+1. `TableNameDialog`: Props: `open`, `onClose`, `database`, `metadata`, `schema`, `table?` (undefined=create mode). Input for table name. Validation: regex `/^\S[\S ]*\S?$/`, no duplicates. Create flow: create `TableMetadata`, push to `schema.tables`, mark "created", create default "id" column, add tab, queue scroll, rebuild tree. Edit flow: update `table.name`, rebuild edit status.
+2. `SchemaNameDialog`: Similar but for schema creation. Input for schema name. Creates `SchemaMetadata`, pushes to `database.schemas`, marks "created", rebuilds tree.
+3. Both use `Dialog`, `DialogTitle`, `DialogDescription` from ui/. Input from ui/.
+**Boundaries**: Does NOT handle rename through context menu (that's wired in T11).
+**Dependencies**: T2, T3, T4
+**Expected Outcome**: Dialogs create/rename tables and schemas correctly
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T23: Create ViewNameDialog, FunctionNameDialog, ProcedureNameDialog [M]
+
+**Objective**: Port ViewNameModal.vue (142), FunctionNameModal.vue (150), ProcedureNameModal.vue (149) to React.
+**Size**: M (3 similar dialogs)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Modals/ViewNameDialog.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Modals/FunctionNameDialog.tsx`
+- Create: `frontend/src/react/components/SchemaEditorLite/Modals/ProcedureNameDialog.tsx`
+**Implementation**:
+1. All follow same pattern as TableNameDialog: Input for name, validation (no duplicates), create flow (create metadata, push to schema, mark "created", add tab, rebuild tree).
+2. `ViewNameDialog`: Creates `ViewMetadata` with empty `definition`.
+3. `FunctionNameDialog`: Creates `FunctionMetadata`.
+4. `ProcedureNameDialog`: Creates `ProcedureMetadata`.
+**Boundaries**: Simpler than TableNameDialog (no default column creation).
+**Dependencies**: T2, T3, T4
+**Expected Outcome**: Dialogs create views/functions/procedures correctly
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T24: Create EditColumnForeignKeySheet [L]
+
+**Objective**: Port EditColumnForeignKeyModal.vue (287 lines) to React using Sheet (wide) from ui/. The most complex modal with cascading dropdowns.
+**Size**: L (multi-field form, cascading selects, FK CRUD)
+**Files**:
+- Create: `frontend/src/react/components/SchemaEditorLite/Modals/EditColumnForeignKeySheet.tsx`
+**Implementation**:
+1. Props: `open`, `onClose`, `database`, `metadata`, `schema`, `table`, `column`, `foreignKey?`.
+2. State: `referencedSchemaName`, `referencedTableName`, `referencedColumnName`, `foreignKeyName`. Initialize from `foreignKey` prop on mount.
+3. Cascading: Schema change → reset table+column. Table change → reset column. Derive options from metadata schemas/tables/columns via `useMemo`.
+4. Schema selector: `Combobox` (hidden if single-schema engine).
+5. Table selector: `Combobox` with tables from selected schema.
+6. Column selector: `Combobox` with columns from selected table.
+7. FK name input: `Input` from ui/.
+8. Confirm: Create new `ForeignKeyMetadata` or update existing. Uses `upsertColumnFromForeignKey()` from `@/components/SchemaEditorLite/edit`.
+9. Delete: Remove column from FK, remove FK if empty. Uses `removeColumnFromForeignKey()`.
+10. Mark column as "updated" after changes.
+**Boundaries**: Uses Sheet (wide) per design.
+**Dependencies**: T2, T4, T15
+**Expected Outcome**: FK editing sheet with cascading dropdowns
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T25: Create ActionConfirmDialog [S]
+
+**Objective**: Port ActionConfirmModal.vue (59 lines) to React using AlertDialog from ui/.
+**Files**: `frontend/src/react/components/SchemaEditorLite/Modals/ActionConfirmDialog.tsx`
+**Implementation**: `AlertDialog` with title, description, cancel, and confirm buttons. Props: `open`, `onClose`, `onConfirm`, `title`, `description`.
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T26: Wire imperative handle and public API [M]
+
+**Objective**: Wire the `forwardRef`/`useImperativeHandle` on SchemaEditorLite to expose `applyMetadataEdit`, `refreshPreview`, `isDirty` to parent components.
+**Size**: M (integration wiring)
+**Files**:
+- Modify: `frontend/src/react/components/SchemaEditorLite/SchemaEditorLite.tsx`
+- Modify: `frontend/src/react/components/SchemaEditorLite/context.tsx`
+**Implementation**:
+1. In `context.tsx`: Add `rebuildMetadataEdit` and `applyMetadataEdit` from `useAlgorithm` to the context value. Add `mergeMetadata()` implementation (port from Vue SchemaEditorLite.vue `mergeTableMetadataToTarge`).
+2. In `SchemaEditorLite.tsx`: Replace stub imperative handle with real implementations. `applyMetadataEdit` → calls context's applyMetadataEdit for each target. `refreshPreview` → calls context's refreshPreview callback. `isDirty` → reads context's isDirty value. Wire `rebuild-edit-status` equivalent: `useEffect` that calls `rebuildMetadataEdit` for each target when triggered.
+**Boundaries**: Does NOT change the public prop interface.
+**Dependencies**: T8 (algorithm), all panel tasks
+**Expected Outcome**: Parent components can call imperative methods on SchemaEditorLite ref
+**Validation**: `pnpm --dir frontend type-check`
+
+---
+
+### T27: Add i18n keys for React schema editor [M]
+
+**Objective**: Add all user-facing strings to the React locale files. Traces to migration playbook requirement.
+**Size**: M (locale key additions across 5 language files)
+**Files**:
+- Modify: `frontend/src/react/locales/en-US.json`
+- Modify: `frontend/src/react/locales/zh-CN.json` (use English placeholders for untranslated)
+- Modify: `frontend/src/react/locales/ja-JP.json` (use English placeholders)
+- Modify: `frontend/src/react/locales/es-ES.json` (use English placeholders)
+- Modify: `frontend/src/react/locales/vi-VN.json` (use English placeholders)
+**Implementation**:
+1. Add keys under `"schema-editor"` namespace for all user-facing strings: toolbar buttons (add-column, add-index, add-partition, columns, indexes, partitions), dialog titles (create-table, rename-table, create-schema, create-view, etc.), validation messages (duplicate-name, invalid-name), status labels (created, updated, dropped), context menu items (create, rename, drop, restore), preview pane labels.
+2. Extract string literals from Vue component templates as reference.
+**Boundaries**: Only en-US gets real translations. Other locales get English placeholders.
+**Dependencies**: All component tasks
+**Expected Outcome**: All `t()` calls in React components resolve to strings
+**Validation**: `pnpm --dir frontend check` — no missing i18n keys
+
+---
+
+### T28: Final validation [M]
+
+**Objective**: Run full frontend validation suite to confirm no regressions.
+**Size**: M (multiple validation commands)
+**Files**: No file changes
+**Implementation**:
+1. `pnpm --dir frontend fix` — auto-fix ESLint + Biome
+2. `pnpm --dir frontend check` — validate
+3. `pnpm --dir frontend type-check` — TypeScript
+4. `pnpm --dir frontend test` — unit tests
+5. Verify Vue SchemaEditorLite is untouched: `git diff frontend/src/components/SchemaEditorLite/` — no changes
+**Boundaries**: Does NOT include manual browser testing.
+**Dependencies**: All tasks
+**Expected Outcome**: All 4 validation commands pass, Vue files unmodified
+**Validation**: All commands exit 0
+
+---
+
+## Out-of-Scope Tasks
+
+- **SchemaDiagram migration** — separate surface with different callers (ER diagram viewer)
+- **SchemaPane migration** — separate surface in SQL editor sidebar
+- **Vue caller migration** — Plan/Issue pages, SQL editor panels continue using Vue SchemaEditorLite
+- **Virtual scroll optimization for TableColumnEditor** — standard table in first pass, virtualization added later if needed
+- **Schema diagram sub-tab in DatabaseEditor** — shows placeholder/hidden in React version
+- **Browser/E2E testing** — requires running dev server with database backends
+- **Vue file deletion** — Vue SchemaEditorLite files remain for existing callers
diff --git a/frontend/package.json b/frontend/package.json
index eda4d8b8e8..a1a6dc0a1d 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -77,9 +77,11 @@
"qrcode.react": "^4.2.0",
"qs": "6.15.0",
"react": "^19.2.4",
+ "react-arborist": "^3.4.3",
"react-dom": "^19.2.4",
"react-i18next": "^16.6.6",
"react-markdown": "^10.1.0",
+ "react-resizable-panels": "^4.10.0",
"regenerator-runtime": "^0.14.1",
"rxjs": "^7.8.2",
"scroll-into-view-if-needed": "^3.1.0",
diff --git a/frontend/pnpm-lock.yaml b/frontend/pnpm-lock.yaml
index 43a8f7e790..1a8236c63b 100644
--- a/frontend/pnpm-lock.yaml
+++ b/frontend/pnpm-lock.yaml
@@ -177,6 +177,9 @@ importers:
react:
specifier: ^19.2.4
version: 19.2.4
+ react-arborist:
+ specifier: ^3.4.3
react-dom:
specifier: ^19.2.4
version: 19.2.4([email protected])
@@ -186,6 +189,9 @@ importers:
react-markdown:
specifier: ^10.1.0
version: 10.1.0(@types/[email protected])([email protected])
+ react-resizable-panels:
+ specifier: ^4.10.0
regenerator-runtime:
specifier: ^0.14.1
version: 0.14.1
@@ -1010,28 +1016,24 @@ packages:
engines: {node: '>=14.21.3'}
cpu: [arm64]
os: [linux]
- libc: [musl]
'@biomejs/[email protected]':
resolution: {integrity: sha512-kMLaI7OF5GN1Q8Doymjro1P8rVEoy7BKQALNz6fiR8IC1WKduoNyteBtJlHT7ASIL0Cx2jR6VUOBIbcB1B8pew==}
engines: {node: '>=14.21.3'}
cpu: [arm64]
os: [linux]
- libc: [glibc]
'@biomejs/[email protected]':
resolution: {integrity: sha512-C9s98IPDu7DYarjlZNuzJKTjVHN03RUnmHV5htvqsx6vEUXCDSJ59DNwjKVD5XYoSS4N+BYhq3RTBAL8X6svEg==}
engines: {node: '>=14.21.3'}
cpu: [x64]
os: [linux]
- libc: [musl]
'@biomejs/[email protected]':
resolution: {integrity: sha512-oHXmUFEoH8Lql1xfc3QkFLiC1hGR7qedv5eKNlC185or+o4/4HiaU7vYODAH3peRCfsuLr1g6v2fK9dFFOYdyw==}
engines: {node: '>=14.21.3'}
cpu: [x64]
os: [linux]
- libc: [glibc]
'@biomejs/[email protected]':
resolution: {integrity: sha512-xzThn87Pf3YrOGTEODFGONmqXpTwUNxovQb72iaUOdcw8sBSY3+3WD8Hm9IhMYLnPi0n32s3L3NWU6+eSjfqFg==}
@@ -1883,6 +1885,15 @@ packages:
'@popperjs/[email protected]':
resolution: {integrity: sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==}
+ '@react-dnd/[email protected]':
+ resolution: {integrity: sha512-kLy0PJDDwvwwTXxqTFNAAllPHD73AycE9ypWeln/IguoGBEbvFcPDbCV03G52bEcC5E+YgupBE0VzHGdC8SIXg==}
+
+ '@react-dnd/[email protected]':
+ resolution: {integrity: sha512-xL4RCQBCBDJ+GRwKTFhGUW8GXa4yoDfJrPbLblc3U09ciS+9ZJXJ3Qrcs/x2IODOdIE5kQxvMmE2UKyqUictUw==}
+
+ '@react-dnd/[email protected]':
+ resolution: {integrity: sha512-Pc/AFTdwZwEKJxFJvlxrSmGe/di+aAOBn60sremrpLo6VI/6cmiUYNNwlI5KNYttg7uypzA3ILPMPgxB2GYZEg==}
+
'@rolldown/[email protected]':
resolution: {integrity: sha512-izyXV/v+cHiRfozX62W9htOAvwMo4/bXKDrQ+vom1L1qRuexPock/7VZDAhnpHCLNejd3NJ6hiab+tO0D44Rgw==}
@@ -1938,79 +1949,66 @@ packages:
resolution: {integrity: sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==}
cpu: [arm]
os: [linux]
- libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==}
cpu: [arm]
os: [linux]
- libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==}
cpu: [arm64]
os: [linux]
- libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==}
cpu: [arm64]
os: [linux]
- libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==}
cpu: [loong64]
os: [linux]
- libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==}
cpu: [loong64]
os: [linux]
- libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==}
cpu: [ppc64]
os: [linux]
- libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==}
cpu: [ppc64]
os: [linux]
- libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==}
cpu: [riscv64]
os: [linux]
- libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==}
cpu: [riscv64]
os: [linux]
- libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==}
cpu: [s390x]
os: [linux]
- libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==}
cpu: [x64]
os: [linux]
- libc: [glibc]
'@rollup/[email protected]':
resolution: {integrity: sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==}
cpu: [x64]
os: [linux]
- libc: [musl]
'@rollup/[email protected]':
resolution: {integrity: sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==}
@@ -2088,28 +2086,24 @@ packages:
engines: {node: '>= 20'}
cpu: [arm64]
os: [linux]
- libc: [glibc]
'@tailwindcss/[email protected]':
resolution: {integrity: sha512-WZA0CHRL/SP1TRbA5mp9htsppSEkWuQ4KsSUumYQnyl8ZdT39ntwqmz4IUHGN6p4XdSlYfJwM4rRzZLShHsGAQ==}
engines: {node: '>= 20'}
cpu: [arm64]
os: [linux]
- libc: [musl]
'@tailwindcss/[email protected]':
resolution: {integrity: sha512-qMFzxI2YlBOLW5PhblzuSWlWfwLHaneBE0xHzLrBgNtqN6mWfs+qYbhryGSXQjFYB1Dzf5w+LN5qbUTPhW7Y5g==}
engines: {node: '>= 20'}
cpu: [x64]
os: [linux]
- libc: [glibc]
'@tailwindcss/[email protected]':
resolution: {integrity: sha512-5r1X2FKnCMUPlXTWRYpHdPYUY6a1Ar/t7P24OuiEdEOmms5lyqjDRvVY1yy9Rmioh+AunQ0rWiOTPE8F9A3v5g==}
engines: {node: '>= 20'}
cpu: [x64]
os: [linux]
- libc: [musl]
'@tailwindcss/[email protected]':
resolution: {integrity: sha512-MGFB5cVPvshR85MTJkEvqDUnuNoysrsRxd6vnk1Lf2tbiqNlXpHYZqkqOQalydienEWOHHFyyuTSYRsLfxFJ2Q==}
@@ -3070,6 +3064,9 @@ packages:
resolution: {integrity: sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==}
+ resolution: {integrity: sha512-+PVS2VPTgKFPYWo3vAFEA8WPbTf7/xo43TifH9G8S1KqnrQu0o77A3unrF5yOugy4mIz7K5wAVFHUcha7wsz6A==}
+
resolution: {integrity: sha512-qkdCKzLNtrgPFP1Vo+98FRzJnBRGe4ffyCea9IwHB1fyxPOeNTHpLKYGd4Uk9xvNoH0ZoOjwZxNptyMwqrId1Q==}
@@ -3449,6 +3446,9 @@ packages:
resolution: {integrity: sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w==}
engines: {node: '>=12.0.0'}
+ resolution: {integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==}
+
resolution: {integrity: sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==}
@@ -3788,28 +3788,24 @@ packages:
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [linux]
- libc: [glibc]
resolution: {integrity: sha512-mVZ7Pg2zIbe3XlNbZJdjs86YViQFoJSpc41CbVmKBPiGmC4YrfeOyz65ms2qpAobVd7WQsbW4PdsSJEMymyIMg==}
engines: {node: '>= 12.0.0'}
cpu: [arm64]
os: [linux]
- libc: [musl]
resolution: {integrity: sha512-xGlFWRMl+0KvUhgySdIaReQdB4FNudfUTARn7q0hh/V67PVGCs3ADFjw+6++kG1RNd0zdGRlEKa+T13/tQjPMA==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [linux]
- libc: [glibc]
resolution: {integrity: sha512-eowF8PrKHw9LpoZii5tdZwnBcYDxRw2rRCyvAXLi34iyeYfqCQNA9rmUM0ce62NlPhCvof1+9ivRaTY6pSKDaA==}
engines: {node: '>= 12.0.0'}
cpu: [x64]
os: [linux]
- libc: [musl]
resolution: {integrity: sha512-aJReEbSEQzx1uBlQizAOBSjcmr9dCdL3XuC/6HLXAxmtErsj2ICo5yYggg1qOODQMtnjNQv2UHb9NpOuFtYe4w==}
@@ -3952,6 +3948,9 @@ packages:
resolution: {integrity: sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==}
+ resolution: {integrity: sha512-zYiwtZUcYyXKo/np96AGZAckk+FWWsUdJ3cHGGmld7+AhvcWmQyGCYUh1hc4Q/pkOhb65dQR/pqCyK0cOaHz4Q==}
+
resolution: {integrity: sha512-pxQJQzB6djGPXh08dacEloMFopsOqGVRKFPYvPOt9XDZ1HasbgDZA74CJGreSU4G3Ak7EFJGoiH2auq+yXISgA==}
engines: {node: '>=18'}
@@ -4381,6 +4380,30 @@ packages:
resolution: {integrity: sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==}
engines: {node: '>=0.12'}
+ resolution: {integrity: sha512-yFnq1nIQhT2uJY4TZVz2tgAiBb9lxSyvF4vC3S8POCK8xLzjGIxVv3/4dmYquQJ7AHxaZZArRGHiHKsEewKdTQ==}
+ peerDependencies:
+ react: '>= 16.14'
+ react-dom: '>= 16.14'
+
+ resolution: {integrity: sha512-6ONeqEC3XKVf4eVmMTe0oPds+c5B9Foyj8p/ZKLb7kL2qh9COYxiBHv3szd6gztqi/efkmriywLUVlPotqoJyw==}
+
+ resolution: {integrity: sha512-9i1jSgbyVw0ELlEVt/NkCUkxy1hmhJOkePoCH713u75vzHGyXhPDm28oLfc2NMSBjZRM1Y+wRjHXJT3sPrTy+A==}
+ peerDependencies:
+ '@types/hoist-non-react-statics': '>= 3.3.1'
+ '@types/node': '>= 12'
+ '@types/react': '>= 16'
+ react: '>= 16.14'
+ peerDependenciesMeta:
+ '@types/hoist-non-react-statics':
+ optional: true
+ '@types/node':
+ optional: true
+ '@types/react':
+ optional: true
+
resolution: {integrity: sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==}
peerDependencies:
@@ -4402,12 +4425,28 @@ packages:
typescript:
optional: true
+ resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
+
resolution: {integrity: sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ==}
peerDependencies:
'@types/react': '>=18'
react: '>=18'
+ resolution: {integrity: sha512-frjewRQt7TCv/vCH1pJfjZ7RxAhr5pKuqVQtVgzFq/vherxBFOWyC3xMbryx5Ti2wylViGUFc93Etg4rB3E0UA==}
+ peerDependencies:
+ react: ^18.0.0 || ^19.0.0
+ react-dom: ^18.0.0 || ^19.0.0
+
+ resolution: {integrity: sha512-+SRbUVT2scadgFSWx+R1P754xHPEqvcfSfVX10QYg6POOz+WNgkN48pS+BtZNIMGiL1HYrSEiCkwsMS15QogEQ==}
+ engines: {node: '>8.0.0'}
+ peerDependencies:
+ react: ^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+ react-dom: ^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
resolution: {integrity: sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==}
engines: {node: '>=0.10.0'}
@@ -4429,6 +4468,12 @@ packages:
resolution: {integrity: sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==}
engines: {node: '>= 20.19.0'}
+ resolution: {integrity: sha512-LAUYz4lc+Do8/g7aeRa8JkyDErK6ekstQaqWQrNRW//MY1TvCEpMtpTWvlQ+FPbWCx+Xixu/6SHt5N0HR+SB4w==}
+
+ resolution: {integrity: sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==}
+
resolution: {integrity: sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==}
engines: {node: '>=4'}
@@ -6839,6 +6884,12 @@ snapshots:
'@popperjs/[email protected]': {}
+ '@react-dnd/[email protected]': {}
+
+ '@react-dnd/[email protected]': {}
+
+ '@react-dnd/[email protected]': {}
+
'@rolldown/[email protected]': {}
@@ -8080,6 +8131,12 @@ snapshots:
+ dependencies:
+ '@react-dnd/asap': 4.0.1
+ '@react-dnd/invariant': 2.0.0
+ redux: 4.2.1
+
optionalDependencies:
'@types/trusted-types': 2.0.7
@@ -8509,6 +8566,10 @@ snapshots:
+ dependencies:
+ react-is: 16.13.1
+
@@ -9077,6 +9138,8 @@ snapshots:
+
@@ -9693,6 +9756,36 @@ snapshots:
discontinuous-range: 1.0.0
ret: 0.1.15
+ dependencies:
+ react: 19.2.4
+ react-dnd: 14.0.5(@types/[email protected])(@types/[email protected])([email protected])
+ react-dnd-html5-backend: 14.1.0
+ react-dom: 19.2.4([email protected])
+ redux: 5.0.1
+ use-sync-external-store: 1.6.0([email protected])
+ transitivePeerDependencies:
+ - '@types/hoist-non-react-statics'
+ - '@types/node'
+ - '@types/react'
+
+ dependencies:
+ dnd-core: 14.0.1
+
+ dependencies:
+ '@react-dnd/invariant': 2.0.0
+ '@react-dnd/shallowequal': 2.0.0
+ dnd-core: 14.0.1
+ fast-deep-equal: 3.1.3
+ hoist-non-react-statics: 3.3.2
+ react: 19.2.4
+ optionalDependencies:
+ '@types/node': 25.3.3
+ '@types/react': 19.2.14
+
dependencies:
react: 19.2.4
@@ -9709,6 +9802,8 @@ snapshots:
react-dom: 19.2.4([email protected])
typescript: 6.0.2
+
dependencies:
'@types/hast': 3.0.4
@@ -9727,6 +9822,18 @@ snapshots:
transitivePeerDependencies:
- supports-color
+ dependencies:
+ react: 19.2.4
+ react-dom: 19.2.4([email protected])
+
+ dependencies:
+ '@babel/runtime': 7.29.2
+ memoize-one: 5.2.1
+ react: 19.2.4
+ react-dom: 19.2.4([email protected])
+
@@ -9756,6 +9863,12 @@ snapshots:
+ dependencies:
+ '@babel/runtime': 7.29.2
+
+
dependencies:
regenerate: 1.4.2
diff --git a/frontend/src/react/components/SchemaEditorLite/Aside/AsideTree.tsx b/frontend/src/react/components/SchemaEditorLite/Aside/AsideTree.tsx
new file mode 100644
index 0000000000..c940b18a4f
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Aside/AsideTree.tsx
@@ -0,0 +1,581 @@
+import { create } from "@bufbuild/protobuf";
+import { debounce } from "lodash-es";
+import {
+ ChevronDown,
+ ChevronRight,
+ Database as DatabaseIcon,
+ FileCode,
+ FunctionSquare,
+ Layers,
+ Table2,
+ View,
+} from "lucide-react";
+import { useCallback, useMemo, useRef, useState } from "react";
+import type { NodeRendererProps } from "react-arborist";
+import { Tree } from "react-arborist";
+import { createPortal } from "react-dom";
+import { SearchInput } from "@/react/components/ui/search-input";
+import { cn } from "@/react/lib/utils";
+import type {
+ FunctionMetadata,
+ ProcedureMetadata,
+ ViewMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import {
+ FunctionMetadataSchema,
+ ProcedureMetadataSchema,
+ ViewMetadataSchema,
+} from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../context";
+import { SchemaNameDialog } from "../Modals/SchemaNameDialog";
+import { TableNameDialog } from "../Modals/TableNameDialog";
+import type { EditStatus } from "../types";
+import { NodeCheckbox } from "./NodeCheckbox";
+import type { TreeNode, TreeNodeForTable } from "./tree-builder";
+import { buildTree } from "./tree-builder";
+import { useContextMenu } from "./useContextMenu";
+
+export function AsideTree() {
+ const context = useSchemaEditorContext();
+ const {
+ targets,
+ readonly,
+ tabs,
+ editStatus,
+ selection,
+ scrollStatus,
+ rebuildTree,
+ treeBuildVersion,
+ } = context;
+
+ const [searchPattern, setSearchPattern] = useState("");
+ const containerRef = useRef<HTMLDivElement>(null);
+
+ // Tree data — treeBuildVersion busts the cache after in-place metadata mutations
+ const { tree, nodeMap } = useMemo(
+ () => buildTree(targets, { byInstance: targets.length > 1 }),
+ [targets, treeBuildVersion]
+ );
+
+ const arboristData = useMemo(() => convertToArboristData(tree), [tree]);
+
+ const handleSearchChange = useMemo(
+ () => debounce((value: string) => setSearchPattern(value), 200),
+ []
+ );
+
+ // Context menu
+ const { menuState, menuOptions, showMenu, hideMenu } =
+ useContextMenu(editStatus);
+
+ // Modal state
+ const [tableNameModalCtx, setTableNameModalCtx] = useState<{
+ db: ReturnType<typeof useSchemaEditorContext>["targets"][0]["database"];
+ database: ReturnType<
+ typeof useSchemaEditorContext
+ >["targets"][0]["metadata"];
+ schema: ReturnType<
+ typeof useSchemaEditorContext
+ >["targets"][0]["metadata"]["schemas"][0];
+ table?: TreeNodeForTable["metadata"]["table"];
+ } | null>(null);
+
+ const [schemaNameModalCtx, setSchemaNameModalCtx] = useState<{
+ db: ReturnType<typeof useSchemaEditorContext>["targets"][0]["database"];
+ database: ReturnType<
+ typeof useSchemaEditorContext
+ >["targets"][0]["metadata"];
+ } | null>(null);
+
+ // Handle context menu selection
+ const handleMenuSelect = useCallback(
+ (key: string) => {
+ const node = menuState.node;
+ if (!node) return;
+ hideMenu();
+
+ if (key === "create-schema" && node.type === "database") {
+ setSchemaNameModalCtx({
+ db: node.db,
+ database: node.metadata.database,
+ });
+ } else if (
+ key === "create-table" &&
+ node.type === "group" &&
+ node.group === "table"
+ ) {
+ setTableNameModalCtx({
+ db: node.db,
+ database: node.metadata.database,
+ schema: node.metadata.schema,
+ });
+ } else if (key === "rename-table" && node.type === "table") {
+ setTableNameModalCtx({
+ db: node.db,
+ database: node.metadata.database,
+ schema: node.metadata.schema,
+ table: node.metadata.table,
+ });
+ } else if (key === "drop-table" && node.type === "table") {
+ const status = editStatus.getTableStatus(node.db, node.metadata);
+ if (status === "created") {
+ const idx = node.metadata.schema.tables.indexOf(node.metadata.table);
+ if (idx >= 0) node.metadata.schema.tables.splice(idx, 1);
+ editStatus.removeEditStatus(
+ node.db,
+ { schema: node.metadata.schema, table: node.metadata.table },
+ true
+ );
+ } else {
+ editStatus.markEditStatus(
+ node.db,
+ { schema: node.metadata.schema, table: node.metadata.table },
+ "dropped"
+ );
+ }
+ rebuildTree(false);
+ } else if (key === "restore-table" && node.type === "table") {
+ editStatus.removeEditStatus(
+ node.db,
+ { schema: node.metadata.schema, table: node.metadata.table },
+ false
+ );
+ rebuildTree(false);
+ } else if (key === "drop-schema" && node.type === "schema") {
+ editStatus.markEditStatus(
+ node.db,
+ { schema: node.metadata.schema },
+ "dropped"
+ );
+ rebuildTree(false);
+ } else if (key === "restore-schema" && node.type === "schema") {
+ editStatus.removeEditStatus(
+ node.db,
+ { schema: node.metadata.schema },
+ false
+ );
+ rebuildTree(false);
+ } else if (
+ key === "create-view" &&
+ node.type === "group" &&
+ node.group === "view"
+ ) {
+ const view = create(ViewMetadataSchema, {
+ name: "new_view",
+ definition: "",
+ }) as ViewMetadata;
+ node.metadata.schema.views.push(view);
+ editStatus.markEditStatus(
+ node.db,
+ { schema: node.metadata.schema, view },
+ "created"
+ );
+ tabs.addTab({
+ type: "view",
+ database: node.db,
+ metadata: {
+ database: node.metadata.database,
+ schema: node.metadata.schema,
+ view,
+ },
+ });
+ rebuildTree(false);
+ } else if (
+ key === "create-procedure" &&
+ node.type === "group" &&
+ node.group === "procedure"
+ ) {
+ const procedure = create(ProcedureMetadataSchema, {
+ name: "new_procedure",
+ definition: "",
+ }) as ProcedureMetadata;
+ node.metadata.schema.procedures.push(procedure);
+ editStatus.markEditStatus(
+ node.db,
+ { schema: node.metadata.schema, procedure },
+ "created"
+ );
+ tabs.addTab({
+ type: "procedure",
+ database: node.db,
+ metadata: {
+ database: node.metadata.database,
+ schema: node.metadata.schema,
+ procedure,
+ },
+ });
+ rebuildTree(false);
+ } else if (
+ key === "create-function" &&
+ node.type === "group" &&
+ node.group === "function"
+ ) {
+ const func = create(FunctionMetadataSchema, {
+ name: "new_function",
+ definition: "",
+ }) as FunctionMetadata;
+ node.metadata.schema.functions.push(func);
+ editStatus.markEditStatus(
+ node.db,
+ { schema: node.metadata.schema, function: func },
+ "created"
+ );
+ tabs.addTab({
+ type: "function",
+ database: node.db,
+ metadata: {
+ database: node.metadata.database,
+ schema: node.metadata.schema,
+ function: func,
+ },
+ });
+ rebuildTree(false);
+ } else if (
+ key.startsWith("drop-") &&
+ (node.type === "view" ||
+ node.type === "procedure" ||
+ node.type === "function")
+ ) {
+ editStatus.markEditStatus(
+ node.db,
+ { schema: node.metadata.schema, ...getResourceKey(node) },
+ "dropped"
+ );
+ rebuildTree(false);
+ } else if (
+ key.startsWith("restore-") &&
+ (node.type === "view" ||
+ node.type === "procedure" ||
+ node.type === "function")
+ ) {
+ editStatus.removeEditStatus(
+ node.db,
+ { schema: node.metadata.schema, ...getResourceKey(node) },
+ false
+ );
+ rebuildTree(false);
+ }
+ },
+ [menuState.node, hideMenu, editStatus, rebuildTree, tabs]
+ );
+
+ // Node click handler
+ const handleNodeClick = useCallback(
+ (node: TreeNode) => {
+ if (node.type === "database") {
+ tabs.addTab({
+ type: "database",
+ database: node.db,
+ metadata: node.metadata,
+ });
+ } else if (node.type === "schema") {
+ tabs.addTab({
+ type: "database",
+ database: node.db,
+ metadata: { database: node.metadata.database },
+ selectedSchema: node.metadata.schema.name,
+ });
+ } else if (node.type === "table") {
+ tabs.addTab({
+ type: "table",
+ database: node.db,
+ metadata: node.metadata,
+ });
+ } else if (node.type === "view") {
+ tabs.addTab({
+ type: "view",
+ database: node.db,
+ metadata: node.metadata,
+ });
+ } else if (node.type === "procedure") {
+ tabs.addTab({
+ type: "procedure",
+ database: node.db,
+ metadata: node.metadata,
+ });
+ } else if (node.type === "function") {
+ tabs.addTab({
+ type: "function",
+ database: node.db,
+ metadata: node.metadata,
+ });
+ } else if (node.type === "column") {
+ tabs.addTab({
+ type: "table",
+ database: node.db,
+ metadata: {
+ database: node.metadata.database,
+ schema: node.metadata.schema,
+ table: node.metadata.table,
+ },
+ });
+ scrollStatus.queuePendingScrollToColumn({
+ db: node.db,
+ metadata: node.metadata,
+ });
+ }
+ },
+ [tabs, scrollStatus]
+ );
+
+ const getNodeStatus = useCallback(
+ (node: TreeNode): EditStatus => {
+ if (node.type === "table")
+ return editStatus.getTableStatus(node.db, node.metadata);
+ if (node.type === "column")
+ return editStatus.getColumnStatus(node.db, node.metadata);
+ if (node.type === "schema")
+ return editStatus.getSchemaStatus(node.db, node.metadata);
+ if (node.type === "view")
+ return editStatus.getViewStatus(node.db, node.metadata);
+ if (node.type === "procedure")
+ return editStatus.getProcedureStatus(node.db, node.metadata);
+ if (node.type === "function")
+ return editStatus.getFunctionStatus(node.db, node.metadata);
+ return "normal";
+ },
+ [editStatus]
+ );
+
+ return (
+ <div className="flex size-full flex-col gap-y-2">
+ <div className="sticky top-0 px-1 pt-1">
+ <SearchInput
+ placeholder="Search..."
+ onChange={(e) => handleSearchChange(e.target.value)}
+ className="h-7"
+ />
+ </div>
+ <div ref={containerRef} className="flex-1 overflow-hidden">
+ <Tree
+ data={arboristData}
+ idAccessor="id"
+ searchTerm={searchPattern}
+ searchMatch={(node, term) =>
+ node.data.name.toLowerCase().includes(term.toLowerCase())
+ }
+ rowHeight={28}
+ indent={16}
+ openByDefault={false}
+ width="100%"
+ height={containerRef.current?.clientHeight ?? 400}
+ >
+ {(props) => (
+ <NodeRenderer
+ {...props}
+ nodeMap={nodeMap}
+ onNodeClick={handleNodeClick}
+ onContextMenu={readonly ? undefined : showMenu}
+ getNodeStatus={getNodeStatus}
+ selection={selection}
+ />
+ )}
+ </Tree>
+ </div>
+
+ {/* Context menu portal */}
+ {menuState.show &&
+ menuOptions.length > 0 &&
+ createPortal(
+ <div
+ className="fixed inset-0 z-50"
+ onClick={hideMenu}
+ onContextMenu={(e) => {
+ e.preventDefault();
+ hideMenu();
+ }}
+ >
+ <div
+ className="absolute rounded-sm border border-control-border bg-white py-1 shadow-md"
+ style={{ left: menuState.x, top: menuState.y }}
+ onClick={(e) => e.stopPropagation()}
+ >
+ {menuOptions.map((opt) => (
+ <button
+ key={opt.key}
+ type="button"
+ className="flex w-full items-center px-3 py-1.5 text-left text-sm hover:bg-control-bg-hover"
+ onClick={() => handleMenuSelect(opt.key)}
+ >
+ {opt.label}
+ </button>
+ ))}
+ </div>
+ </div>,
+ document.body
+ )}
+
+ {/* Modals */}
+ {tableNameModalCtx && (
+ <TableNameDialog
+ open
+ onClose={() => setTableNameModalCtx(null)}
+ db={tableNameModalCtx.db}
+ database={tableNameModalCtx.database}
+ schema={tableNameModalCtx.schema}
+ table={tableNameModalCtx.table}
+ />
+ )}
+ {schemaNameModalCtx && (
+ <SchemaNameDialog
+ open
+ onClose={() => setSchemaNameModalCtx(null)}
+ db={schemaNameModalCtx.db}
+ database={schemaNameModalCtx.database}
+ />
+ )}
+ </div>
+ );
+}
+
+// Helper to get resource key for view/procedure/function nodes
+function getResourceKey(node: TreeNode) {
+ if (node.type === "view") return { view: node.metadata.view };
+ if (node.type === "procedure") return { procedure: node.metadata.procedure };
+ if (node.type === "function") return { function: node.metadata.function };
+ return {};
+}
+
+// Convert TreeNode[] to react-arborist compatible format
+interface ArboristNode {
+ id: string;
+ name: string;
+ children?: ArboristNode[];
+}
+
+function convertToArboristData(nodes: TreeNode[]): ArboristNode[] {
+ return nodes.map((node) => ({
+ id: node.key,
+ name: node.label,
+ children:
+ node.children && node.children.length > 0
+ ? convertToArboristData(node.children as TreeNode[])
+ : node.isLeaf
+ ? undefined
+ : [],
+ }));
+}
+
+// Node icon by type
+function NodeIcon({ node }: { node: TreeNode }) {
+ const cls = "size-4 shrink-0";
+ switch (node.type) {
+ case "instance":
+ return <Layers className={cls} />;
+ case "database":
+ return <DatabaseIcon className={cls} />;
+ case "schema":
+ return <Layers className={cls} />;
+ case "table":
+ return <Table2 className={cls} />;
+ case "column":
+ return (
+ <div className={cn(cls, "text-center text-xs font-bold leading-4")}>
+ C
+ </div>
+ );
+ case "view":
+ return <View className={cls} />;
+ case "procedure":
+ return <FileCode className={cls} />;
+ case "function":
+ return <FunctionSquare className={cls} />;
+ case "group":
+ switch (node.group) {
+ case "table":
+ return <Table2 className={cls} />;
+ case "view":
+ return <View className={cls} />;
+ case "procedure":
+ return <FileCode className={cls} />;
+ case "function":
+ return <FunctionSquare className={cls} />;
+ }
+ return null;
+ case "placeholder":
+ return null;
+ }
+}
+
+function statusClassName(status: EditStatus): string {
+ switch (status) {
+ case "created":
+ return "text-success";
+ case "updated":
+ return "text-warning";
+ case "dropped":
+ return "text-error line-through";
+ default:
+ return "";
+ }
+}
+
+// Custom node renderer
+function NodeRenderer(
+ props: NodeRendererProps<ArboristNode> & {
+ nodeMap: Map<string, TreeNode>;
+ onNodeClick: (node: TreeNode) => void;
+ onContextMenu?: (e: React.MouseEvent, node: TreeNode) => void;
+ getNodeStatus: (node: TreeNode) => EditStatus;
+ selection: ReturnType<typeof useSchemaEditorContext>["selection"];
+ }
+) {
+ const {
+ node,
+ style,
+ nodeMap,
+ onNodeClick,
+ onContextMenu,
+ getNodeStatus,
+ selection,
+ } = props;
+ const treeNode = nodeMap.get(node.data.id);
+
+ if (!treeNode) return null;
+ if (treeNode.type === "placeholder") {
+ return (
+ <div
+ style={style}
+ className="flex h-7 items-center px-2 text-xs text-control-light italic"
+ >
+ No items
+ </div>
+ );
+ }
+
+ const status = getNodeStatus(treeNode);
+ const hasChildren = !treeNode.isLeaf;
+
+ return (
+ <div
+ style={style}
+ className={cn(
+ "flex h-7 cursor-pointer items-center gap-x-1 px-1 text-sm hover:bg-control-bg-hover",
+ node.isSelected && "bg-control-bg-hover"
+ )}
+ onClick={(e) => {
+ e.stopPropagation();
+ if (hasChildren) node.toggle();
+ onNodeClick(treeNode);
+ }}
+ onContextMenu={(e) => onContextMenu?.(e, treeNode)}
+ >
+ {hasChildren ? (
+ <span className="flex size-4 shrink-0 items-center justify-center">
+ {node.isOpen ? (
+ <ChevronDown className="size-3" />
+ ) : (
+ <ChevronRight className="size-3" />
+ )}
+ </span>
+ ) : (
+ <span className="size-4 shrink-0" />
+ )}
+ <NodeCheckbox node={treeNode} selection={selection} />
+ <NodeIcon node={treeNode} />
+ <span className={cn("truncate", statusClassName(status))}>
+ {treeNode.label || "(empty)"}
+ </span>
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Aside/NodeCheckbox.tsx b/frontend/src/react/components/SchemaEditorLite/Aside/NodeCheckbox.tsx
new file mode 100644
index 0000000000..8ae3f52397
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Aside/NodeCheckbox.tsx
@@ -0,0 +1,264 @@
+import { useCallback } from "react";
+import type { SelectionContext } from "../types";
+import type {
+ TreeNode,
+ TreeNodeForColumn,
+ TreeNodeForFunction,
+ TreeNodeForGroup,
+ TreeNodeForProcedure,
+ TreeNodeForSchema,
+ TreeNodeForTable,
+ TreeNodeForView,
+} from "./tree-builder";
+
+interface Props {
+ node: TreeNode;
+ selection: SelectionContext;
+}
+
+export function NodeCheckbox({ node, selection }: Props) {
+ if (!selection.selectionEnabled) return null;
+
+ switch (node.type) {
+ case "table":
+ return <TableCheckbox node={node} selection={selection} />;
+ case "column":
+ return <ColumnCheckbox node={node} selection={selection} />;
+ case "view":
+ return <ViewCheckbox node={node} selection={selection} />;
+ case "procedure":
+ return <ProcedureCheckbox node={node} selection={selection} />;
+ case "function":
+ return <FunctionCheckbox node={node} selection={selection} />;
+ case "group":
+ return <GroupCheckbox node={node} selection={selection} />;
+ case "schema":
+ return <SchemaCheckbox node={node} selection={selection} />;
+ default:
+ return null;
+ }
+}
+
+function TableCheckbox({
+ node,
+ selection,
+}: {
+ node: TreeNodeForTable;
+ selection: SelectionContext;
+}) {
+ const state = selection.getTableSelectionState(node.db, node.metadata);
+ const handleChange = useCallback(
+ (e: React.ChangeEvent<HTMLInputElement>) => {
+ selection.updateTableSelection(node.db, node.metadata, e.target.checked);
+ },
+ [selection, node]
+ );
+ return (
+ <input
+ type="checkbox"
+ checked={state.checked}
+ ref={(el) => {
+ if (el) el.indeterminate = state.indeterminate;
+ }}
+ onChange={handleChange}
+ onClick={(e) => e.stopPropagation()}
+ className="size-3.5"
+ />
+ );
+}
+
+function ColumnCheckbox({
+ node,
+ selection,
+}: {
+ node: TreeNodeForColumn;
+ selection: SelectionContext;
+}) {
+ const state = selection.getColumnSelectionState(node.db, node.metadata);
+ const handleChange = useCallback(
+ (e: React.ChangeEvent<HTMLInputElement>) => {
+ selection.updateColumnSelection(node.db, node.metadata, e.target.checked);
+ },
+ [selection, node]
+ );
+ return (
+ <input
+ type="checkbox"
+ checked={state.checked}
+ onChange={handleChange}
+ onClick={(e) => e.stopPropagation()}
+ className="size-3.5"
+ />
+ );
+}
+
+function ViewCheckbox({
+ node,
+ selection,
+}: {
+ node: TreeNodeForView;
+ selection: SelectionContext;
+}) {
+ const state = selection.getViewSelectionState(node.db, node.metadata);
+ const handleChange = useCallback(
+ (e: React.ChangeEvent<HTMLInputElement>) => {
+ selection.updateViewSelection(node.db, node.metadata, e.target.checked);
+ },
+ [selection, node]
+ );
+ return (
+ <input
+ type="checkbox"
+ checked={state.checked}
+ onChange={handleChange}
+ onClick={(e) => e.stopPropagation()}
+ className="size-3.5"
+ />
+ );
+}
+
+function ProcedureCheckbox({
+ node,
+ selection,
+}: {
+ node: TreeNodeForProcedure;
+ selection: SelectionContext;
+}) {
+ const state = selection.getProcedureSelectionState(node.db, node.metadata);
+ const handleChange = useCallback(
+ (e: React.ChangeEvent<HTMLInputElement>) => {
+ selection.updateProcedureSelection(
+ node.db,
+ node.metadata,
+ e.target.checked
+ );
+ },
+ [selection, node]
+ );
+ return (
+ <input
+ type="checkbox"
+ checked={state.checked}
+ onChange={handleChange}
+ onClick={(e) => e.stopPropagation()}
+ className="size-3.5"
+ />
+ );
+}
+
+function FunctionCheckbox({
+ node,
+ selection,
+}: {
+ node: TreeNodeForFunction;
+ selection: SelectionContext;
+}) {
+ const state = selection.getFunctionSelectionState(node.db, node.metadata);
+ const handleChange = useCallback(
+ (e: React.ChangeEvent<HTMLInputElement>) => {
+ selection.updateFunctionSelection(
+ node.db,
+ node.metadata,
+ e.target.checked
+ );
+ },
+ [selection, node]
+ );
+ return (
+ <input
+ type="checkbox"
+ checked={state.checked}
+ onChange={handleChange}
+ onClick={(e) => e.stopPropagation()}
+ className="size-3.5"
+ />
+ );
+}
+
+function GroupCheckbox({
+ node,
+ selection,
+}: {
+ node: TreeNodeForGroup;
+ selection: SelectionContext;
+}) {
+ // Group checkboxes toggle all children of a specific type
+ if (node.group === "table") {
+ const tables = node.children?.filter(
+ (c): c is TreeNodeForTable => c.type === "table"
+ );
+ if (!tables || tables.length === 0) return null;
+ const tableMetas = tables.map((t) => t.metadata.table);
+ const state = selection.getAllTablesSelectionState(
+ node.db,
+ node.metadata,
+ tableMetas
+ );
+ return (
+ <input
+ type="checkbox"
+ checked={state.checked}
+ ref={(el) => {
+ if (el) el.indeterminate = state.indeterminate;
+ }}
+ onChange={(e) => {
+ selection.updateAllTablesSelection(
+ node.db,
+ node.metadata,
+ tableMetas,
+ e.target.checked
+ );
+ }}
+ onClick={(e) => e.stopPropagation()}
+ className="size-3.5"
+ />
+ );
+ }
+
+ if (node.group === "view") {
+ const views = node.children?.filter(
+ (c): c is TreeNodeForView => c.type === "view"
+ );
+ if (!views || views.length === 0) return null;
+ const viewMetas = views.map((v) => v.metadata.view);
+ const state = selection.getAllViewsSelectionState(
+ node.db,
+ node.metadata,
+ viewMetas
+ );
+ return (
+ <input
+ type="checkbox"
+ checked={state.checked}
+ ref={(el) => {
+ if (el) el.indeterminate = state.indeterminate;
+ }}
+ onChange={(e) => {
+ selection.updateAllViewsSelection(
+ node.db,
+ node.metadata,
+ viewMetas,
+ e.target.checked
+ );
+ }}
+ onClick={(e) => e.stopPropagation()}
+ className="size-3.5"
+ />
+ );
+ }
+
+ // Procedure and function group checkboxes follow the same pattern
+ return null;
+}
+
+function SchemaCheckbox({
+ node: _node,
+ selection: _selection,
+}: {
+ node: TreeNodeForSchema;
+ selection: SelectionContext;
+}) {
+ // Schema-level checkbox would aggregate all child groups.
+ // Deferred for simplicity — individual type checkboxes cover the use case.
+ return null;
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Aside/index.ts b/frontend/src/react/components/SchemaEditorLite/Aside/index.ts
new file mode 100644
index 0000000000..9feacaed5b
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Aside/index.ts
@@ -0,0 +1,3 @@
+export { AsideTree } from "./AsideTree";
+export type { TreeNode } from "./tree-builder";
+export { buildTree } from "./tree-builder";
diff --git a/frontend/src/react/components/SchemaEditorLite/Aside/tree-builder.ts b/frontend/src/react/components/SchemaEditorLite/Aside/tree-builder.ts
new file mode 100644
index 0000000000..55aebe706e
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Aside/tree-builder.ts
@@ -0,0 +1,524 @@
+import { keyForResource } from "@/components/SchemaEditorLite/context/common";
+import {
+ engineSupportsEditFunctions,
+ engineSupportsEditProcedures,
+ engineSupportsEditViews,
+} from "@/components/SchemaEditorLite/spec";
+import type {
+ ColumnMetadata,
+ Database,
+ DatabaseMetadata,
+ FunctionMetadata,
+ ProcedureMetadata,
+ SchemaMetadata,
+ TableMetadata,
+ ViewMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import type { InstanceResource } from "@/types/proto-es/v1/instance_service_pb";
+import {
+ extractDatabaseResourceName,
+ getDatabaseEngine,
+ getInstanceResource,
+ groupBy,
+} from "@/utils";
+import type { EditTarget } from "../types";
+
+// Tree node types — framework-agnostic (no naive-ui TreeOption dependency).
+// react-arborist uses `id` + `name` + `children` by default,
+// but we keep `key` + `label` + `children` and map in the component.
+
+export interface BaseTreeNode {
+ key: string;
+ label: string;
+ isLeaf: boolean;
+ children?: TreeNode[];
+}
+
+export interface TreeNodeForInstance extends BaseTreeNode {
+ type: "instance";
+ instance: InstanceResource;
+ children: TreeNodeForDatabase[];
+}
+
+export interface TreeNodeForDatabase extends BaseTreeNode {
+ type: "database";
+ db: Database;
+ metadata: {
+ database: DatabaseMetadata;
+ };
+ children: TreeNodeForSchema[] | TreeNodeForGroup[];
+}
+
+export interface TreeNodeForSchema extends BaseTreeNode {
+ type: "schema";
+ db: Database;
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ };
+ children: TreeNodeForGroup[];
+}
+
+export interface TreeNodeForTable extends BaseTreeNode {
+ type: "table";
+ db: Database;
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ };
+ children: TreeNodeForColumn[] | TreeNodeForPlaceholder<"column">[];
+}
+
+export interface TreeNodeForColumn extends BaseTreeNode {
+ type: "column";
+ db: Database;
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ };
+ children: undefined;
+ isLeaf: true;
+}
+
+export interface TreeNodeForView extends BaseTreeNode {
+ type: "view";
+ db: Database;
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ view: ViewMetadata;
+ };
+ children: undefined;
+ isLeaf: true;
+}
+
+export interface TreeNodeForProcedure extends BaseTreeNode {
+ type: "procedure";
+ db: Database;
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ procedure: ProcedureMetadata;
+ };
+ children: undefined;
+ isLeaf: true;
+}
+
+export interface TreeNodeForFunction extends BaseTreeNode {
+ type: "function";
+ db: Database;
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ function: FunctionMetadata;
+ };
+ children: undefined;
+ isLeaf: true;
+}
+
+export type GroupNodeType = "table" | "view" | "procedure" | "function";
+
+export interface TreeNodeForGroup<T extends GroupNodeType = GroupNodeType>
+ extends BaseTreeNode {
+ type: "group";
+ group: T;
+ db: Database;
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ };
+ isLeaf: false;
+ children: T extends "table"
+ ? TreeNodeForTable[] | TreeNodeForPlaceholder<"table">[]
+ : T extends "view"
+ ? TreeNodeForView[] | TreeNodeForPlaceholder<"view">[]
+ : T extends "procedure"
+ ? TreeNodeForProcedure[] | TreeNodeForPlaceholder<"procedure">[]
+ : T extends "function"
+ ? TreeNodeForFunction[] | TreeNodeForPlaceholder<"function">[]
+ : never;
+}
+
+export type PlaceholderNodeType =
+ | "table"
+ | "column"
+ | "view"
+ | "procedure"
+ | "function";
+
+export interface TreeNodeForPlaceholder<
+ T extends PlaceholderNodeType = PlaceholderNodeType,
+> extends BaseTreeNode {
+ type: "placeholder";
+ placeholder: T;
+ isLeaf: true;
+ children: undefined;
+}
+
+export type TreeNode =
+ | TreeNodeForInstance
+ | TreeNodeForDatabase
+ | TreeNodeForSchema
+ | TreeNodeForTable
+ | TreeNodeForColumn
+ | TreeNodeForView
+ | TreeNodeForProcedure
+ | TreeNodeForFunction
+ | TreeNodeForGroup
+ | TreeNodeForPlaceholder;
+
+export type BuildTreeOptions = {
+ byInstance: boolean;
+};
+
+export type BuildTreeResult = {
+ tree: TreeNode[];
+ nodeMap: Map<string, TreeNode>;
+};
+
+export function buildTree(
+ targets: EditTarget[],
+ options: BuildTreeOptions = { byInstance: true }
+): BuildTreeResult {
+ const nodeMap = new Map<string, TreeNode>();
+
+ let tree: TreeNode[];
+ if (options.byInstance) {
+ tree = buildInstanceNodeList(targets, nodeMap);
+ } else {
+ const target = targets[0];
+ tree = buildSchemaNodeList(
+ target.metadata.schemas,
+ nodeMap,
+ target.database,
+ target.metadata
+ );
+ }
+
+ return { tree, nodeMap };
+}
+
+function buildInstanceNodeList(
+ targets: EditTarget[],
+ map: Map<string, TreeNode>
+): TreeNodeForInstance[] {
+ const groupedByInstance = groupBy(
+ targets,
+ (target) => extractDatabaseResourceName(target.database.name).instance
+ );
+ return Array.from(groupedByInstance).map(([key, targets]) => {
+ const instance = getInstanceResource(targets[0].database);
+ const instanceNode: TreeNodeForInstance = {
+ type: "instance",
+ key,
+ label: instance.title,
+ isLeaf: false,
+ instance,
+ children: [],
+ };
+ map.set(instanceNode.key, instanceNode);
+ instanceNode.children = buildDatabaseNodeList(targets, map);
+ return instanceNode;
+ });
+}
+
+function buildDatabaseNodeList(
+ targets: EditTarget[],
+ map: Map<string, TreeNode>
+): TreeNodeForDatabase[] {
+ return targets.map((target) => {
+ const db = target.database;
+ const databaseNode: TreeNodeForDatabase = {
+ type: "database",
+ key: db.name,
+ label: extractDatabaseResourceName(db.name).databaseName,
+ isLeaf: false,
+ db,
+ metadata: {
+ database: target.metadata,
+ },
+ children: [],
+ };
+ map.set(databaseNode.key, databaseNode);
+ databaseNode.children = buildSchemaNodeList(
+ target.metadata.schemas,
+ map,
+ db,
+ target.metadata
+ ) as TreeNodeForSchema[] | TreeNodeForGroup[];
+ return databaseNode;
+ });
+}
+
+function buildSchemaNodeList(
+ schemas: SchemaMetadata[],
+ map: Map<string, TreeNode>,
+ db: Database,
+ database: DatabaseMetadata
+): (TreeNodeForSchema | TreeNodeForGroup)[] {
+ const mapSchemaChildrenNodes = (
+ schema: SchemaMetadata
+ ): TreeNodeForGroup[] => {
+ const groups: TreeNodeForGroup[] = [];
+ const metadata = { database, schema };
+
+ // Tables
+ const tableGroupNode: TreeNodeForGroup<"table"> = {
+ type: "group",
+ group: "table",
+ key: keyForResource(db, metadata, "table-group"),
+ db,
+ metadata,
+ label: "Tables",
+ children: [],
+ isLeaf: false,
+ };
+ tableGroupNode.children = buildTableNodeList(
+ schema.tables,
+ map,
+ tableGroupNode
+ );
+ if (tableGroupNode.children.length === 0) {
+ tableGroupNode.children = [
+ buildPlaceholderNode("table", tableGroupNode, map),
+ ];
+ }
+ groups.push(tableGroupNode);
+ map.set(tableGroupNode.key, tableGroupNode);
+
+ // Views
+ if (engineSupportsEditViews(getDatabaseEngine(db))) {
+ const viewGroupNode: TreeNodeForGroup<"view"> = {
+ type: "group",
+ group: "view",
+ key: keyForResource(db, metadata, "view-group"),
+ db,
+ metadata,
+ label: "Views",
+ children: [],
+ isLeaf: false,
+ };
+ viewGroupNode.children = buildViewNodeList(
+ schema.views,
+ map,
+ viewGroupNode
+ );
+ if (viewGroupNode.children.length === 0) {
+ viewGroupNode.children = [
+ buildPlaceholderNode("view", viewGroupNode, map),
+ ];
+ }
+ groups.push(viewGroupNode);
+ map.set(viewGroupNode.key, viewGroupNode);
+ }
+
+ // Procedures
+ if (engineSupportsEditProcedures(getDatabaseEngine(db))) {
+ const procedureGroupNode: TreeNodeForGroup<"procedure"> = {
+ type: "group",
+ group: "procedure",
+ key: keyForResource(db, metadata, "procedure-group"),
+ db,
+ metadata,
+ label: "Procedures",
+ children: [],
+ isLeaf: false,
+ };
+ procedureGroupNode.children = buildProcedureNodeList(
+ schema.procedures,
+ map,
+ procedureGroupNode
+ );
+ if (procedureGroupNode.children.length === 0) {
+ procedureGroupNode.children = [
+ buildPlaceholderNode("procedure", procedureGroupNode, map),
+ ];
+ }
+ groups.push(procedureGroupNode);
+ map.set(procedureGroupNode.key, procedureGroupNode);
+ }
+
+ // Functions
+ if (engineSupportsEditFunctions(getDatabaseEngine(db))) {
+ const functionGroupNode: TreeNodeForGroup<"function"> = {
+ type: "group",
+ group: "function",
+ key: keyForResource(db, metadata, "function-group"),
+ db,
+ metadata,
+ label: "Functions",
+ children: [],
+ isLeaf: false,
+ };
+ functionGroupNode.children = buildFunctionNodeList(
+ schema.functions,
+ map,
+ functionGroupNode
+ );
+ if (functionGroupNode.children.length === 0) {
+ functionGroupNode.children = [
+ buildPlaceholderNode("function", functionGroupNode, map),
+ ];
+ }
+ groups.push(functionGroupNode);
+ map.set(functionGroupNode.key, functionGroupNode);
+ }
+
+ return groups;
+ };
+
+ // MySQL, TiDB has only one "schema" with empty name
+ if (schemas.length === 1 && schemas[0].name === "") {
+ return mapSchemaChildrenNodes(schemas[0]);
+ }
+
+ return schemas.map((schema) => {
+ const metadata = { database, schema };
+ const schemaNode: TreeNodeForSchema = {
+ type: "schema",
+ key: keyForResource(db, metadata),
+ label: schema.name,
+ isLeaf: false,
+ db,
+ metadata,
+ children: [],
+ };
+ schemaNode.children = mapSchemaChildrenNodes(schema);
+ map.set(schemaNode.key, schemaNode);
+ return schemaNode;
+ });
+}
+
+function buildTableNodeList(
+ tables: TableMetadata[],
+ map: Map<string, TreeNode>,
+ parent: TreeNodeForGroup<"table">
+): TreeNodeForTable[] {
+ return tables.map((table) => {
+ const { db } = parent;
+ const metadata = { ...parent.metadata, table };
+ const tableNode: TreeNodeForTable = {
+ type: "table",
+ key: keyForResource(db, metadata),
+ label: table.name,
+ isLeaf: false,
+ db,
+ metadata,
+ children: [],
+ };
+ map.set(tableNode.key, tableNode);
+ tableNode.children = buildColumnNodeList(table.columns, map, tableNode);
+ if (tableNode.children.length === 0) {
+ tableNode.children = [buildPlaceholderNode("column", tableNode, map)];
+ }
+ return tableNode;
+ });
+}
+
+function buildViewNodeList(
+ views: ViewMetadata[],
+ map: Map<string, TreeNode>,
+ parent: TreeNodeForGroup<"view">
+): TreeNodeForView[] {
+ return views.map((view) => {
+ const { db } = parent;
+ const metadata = { ...parent.metadata, view };
+ const viewNode: TreeNodeForView = {
+ type: "view",
+ key: keyForResource(db, metadata),
+ label: view.name,
+ isLeaf: true,
+ db,
+ metadata,
+ children: undefined,
+ };
+ map.set(viewNode.key, viewNode);
+ return viewNode;
+ });
+}
+
+function buildProcedureNodeList(
+ procedures: ProcedureMetadata[],
+ map: Map<string, TreeNode>,
+ parent: TreeNodeForGroup<"procedure">
+): TreeNodeForProcedure[] {
+ return procedures.map((procedure) => {
+ const { db } = parent;
+ const metadata = { ...parent.metadata, procedure };
+ const procedureNode: TreeNodeForProcedure = {
+ type: "procedure",
+ key: keyForResource(db, metadata),
+ label: procedure.signature || procedure.name,
+ isLeaf: true,
+ db,
+ metadata,
+ children: undefined,
+ };
+ map.set(procedureNode.key, procedureNode);
+ return procedureNode;
+ });
+}
+
+function buildFunctionNodeList(
+ functions: FunctionMetadata[],
+ map: Map<string, TreeNode>,
+ parent: TreeNodeForGroup<"function">
+): TreeNodeForFunction[] {
+ return functions.map((func) => {
+ const { db } = parent;
+ const metadata = { ...parent.metadata, function: func };
+ const functionNode: TreeNodeForFunction = {
+ type: "function",
+ key: keyForResource(db, metadata),
+ label: func.signature || func.name,
+ isLeaf: true,
+ db,
+ metadata,
+ children: undefined,
+ };
+ map.set(functionNode.key, functionNode);
+ return functionNode;
+ });
+}
+
+function buildColumnNodeList(
+ columns: ColumnMetadata[],
+ map: Map<string, TreeNode>,
+ parent: TreeNodeForTable
+): TreeNodeForColumn[] {
+ return columns.map((column) => {
+ const { db } = parent;
+ const metadata = { ...parent.metadata, column };
+ const columnNode: TreeNodeForColumn = {
+ type: "column",
+ key: keyForResource(db, metadata),
+ label: column.name,
+ db,
+ metadata,
+ isLeaf: true,
+ children: undefined,
+ };
+ map.set(columnNode.key, columnNode);
+ return columnNode;
+ });
+}
+
+function buildPlaceholderNode<T extends PlaceholderNodeType>(
+ placeholder: T,
+ parent: TreeNode,
+ map: Map<string, TreeNode>
+): TreeNodeForPlaceholder<T> {
+ const node: TreeNodeForPlaceholder<T> = {
+ type: "placeholder",
+ key: `${parent.key}/placeholder`,
+ placeholder,
+ label: "",
+ children: undefined,
+ isLeaf: true,
+ };
+ map.set(node.key, node);
+ return node;
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Aside/useContextMenu.ts b/frontend/src/react/components/SchemaEditorLite/Aside/useContextMenu.ts
new file mode 100644
index 0000000000..15d366ab7b
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Aside/useContextMenu.ts
@@ -0,0 +1,164 @@
+import { useCallback, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { engineSupportsMultiSchema } from "@/components/SchemaEditorLite/spec";
+import { Engine } from "@/types/proto-es/v1/common_pb";
+import type { Database } from "@/types/proto-es/v1/database_service_pb";
+import { getDatabaseEngine } from "@/utils";
+import type { EditStatusContext } from "../types";
+import type { TreeNode } from "./tree-builder";
+
+export interface MenuState {
+ show: boolean;
+ x: number;
+ y: number;
+ node?: TreeNode;
+}
+
+export interface MenuOption {
+ key: string;
+ label: string;
+}
+
+export function useContextMenu(editStatus: EditStatusContext) {
+ const { t } = useTranslation();
+ const [menuState, setMenuState] = useState<MenuState>({
+ show: false,
+ x: 0,
+ y: 0,
+ });
+
+ const menuOptions = useMemo((): MenuOption[] => {
+ const { node } = menuState;
+ if (!node) return [];
+ if (!("db" in node)) return [];
+
+ const engine = getDatabaseEngine(node.db as Database);
+
+ if (node.type === "database") {
+ if (engineSupportsMultiSchema(engine)) {
+ return [
+ {
+ key: "create-schema",
+ label: t("schema-editor.actions.create-schema"),
+ },
+ ];
+ }
+ return [];
+ }
+
+ if (node.type === "schema") {
+ if (engine === Engine.POSTGRES) {
+ const status = editStatus.getSchemaStatus(node.db, node.metadata);
+ if (status === "dropped") {
+ return [
+ {
+ key: "restore-schema",
+ label: t("schema-editor.actions.restore"),
+ },
+ ];
+ }
+ return [
+ {
+ key: "drop-schema",
+ label: t("schema-editor.actions.drop-schema"),
+ },
+ ];
+ }
+ return [];
+ }
+
+ if (node.type === "group") {
+ const createLabels: Record<string, string> = {
+ table: t("schema-editor.actions.create-table"),
+ view: t("schema-editor.actions.create-view"),
+ procedure: t("schema-editor.actions.create-procedure"),
+ function: t("schema-editor.actions.create-function"),
+ };
+ return [
+ {
+ key: `create-${node.group}`,
+ label: createLabels[node.group] ?? "",
+ },
+ ];
+ }
+
+ if (node.type === "table") {
+ const status = editStatus.getTableStatus(node.db, node.metadata);
+ if (status === "dropped") {
+ return [
+ {
+ key: "restore-table",
+ label: t("schema-editor.actions.restore"),
+ },
+ ];
+ }
+ const options: MenuOption[] = [];
+ if (status !== "normal") {
+ options.push({
+ key: "rename-table",
+ label: t("schema-editor.actions.rename"),
+ });
+ }
+ options.push({
+ key: "drop-table",
+ label: t("schema-editor.actions.drop-table"),
+ });
+ return options;
+ }
+
+ if (node.type === "view") {
+ const status = editStatus.getViewStatus(node.db, node.metadata);
+ if (status === "dropped") {
+ return [
+ {
+ key: "restore-view",
+ label: t("schema-editor.actions.restore"),
+ },
+ ];
+ }
+ return [{ key: "drop-view", label: t("schema-editor.actions.drop") }];
+ }
+
+ if (node.type === "procedure") {
+ const status = editStatus.getProcedureStatus(node.db, node.metadata);
+ if (status === "dropped") {
+ return [
+ {
+ key: "restore-procedure",
+ label: t("schema-editor.actions.restore"),
+ },
+ ];
+ }
+ return [
+ { key: "drop-procedure", label: t("schema-editor.actions.drop") },
+ ];
+ }
+
+ if (node.type === "function") {
+ const status = editStatus.getFunctionStatus(node.db, node.metadata);
+ if (status === "dropped") {
+ return [
+ {
+ key: "restore-function",
+ label: t("schema-editor.actions.restore"),
+ },
+ ];
+ }
+ return [{ key: "drop-function", label: t("schema-editor.actions.drop") }];
+ }
+
+ return [];
+ }, [menuState, editStatus, t]);
+
+ const showMenu = useCallback((e: React.MouseEvent, node: TreeNode) => {
+ e.preventDefault();
+ e.stopPropagation();
+ setMenuState({ show: true, x: e.clientX, y: e.clientY, node });
+ }, []);
+
+ const hideMenu = useCallback(() => {
+ setMenuState((prev) => ({ ...prev, show: false }));
+ }, []);
+
+ return { menuState, menuOptions, showMenu, hideMenu };
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/EditorPanel.tsx b/frontend/src/react/components/SchemaEditorLite/EditorPanel.tsx
new file mode 100644
index 0000000000..17c0757447
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/EditorPanel.tsx
@@ -0,0 +1,87 @@
+import { useCallback, useState } from "react";
+import { useSchemaEditorContext } from "./context";
+import { DatabaseEditor } from "./Panels/DatabaseEditor";
+import { FunctionEditor } from "./Panels/FunctionEditor";
+import { ProcedureEditor } from "./Panels/ProcedureEditor";
+import { TableEditor } from "./Panels/TableEditor";
+import { ViewEditor } from "./Panels/ViewEditor";
+import { TabsContainer } from "./TabsContainer";
+
+export function EditorPanel() {
+ const { tabs } = useSchemaEditorContext();
+ const { currentTab } = tabs;
+
+ // Per-tab schema selection. User choices are stored by tab ID so they
+ // don't leak across tabs. Falls back to the tab's initial selectedSchema
+ // (set when navigating from a schema node in the tree).
+ const [selectedSchemas, setSelectedSchemas] = useState<
+ Record<string, string | undefined>
+ >({});
+
+ const selectedSchemaName = currentTab
+ ? (selectedSchemas[currentTab.id] ??
+ (currentTab.type === "database" ? currentTab.selectedSchema : undefined))
+ : undefined;
+
+ const handleSchemaNameChange = useCallback(
+ (name: string | undefined) => {
+ if (currentTab) {
+ setSelectedSchemas((prev) => ({ ...prev, [currentTab.id]: name }));
+ }
+ },
+ [currentTab]
+ );
+
+ return (
+ <main className="flex size-full flex-col overflow-y-hidden">
+ <TabsContainer />
+ <div className="flex-1 overflow-y-hidden" key={currentTab?.id ?? "empty"}>
+ {!currentTab && (
+ <div className="flex size-full items-center justify-center text-sm text-control-light">
+ Select a database object from the tree to edit
+ </div>
+ )}
+ {currentTab?.type === "database" && (
+ <DatabaseEditor
+ db={currentTab.database}
+ database={currentTab.metadata.database}
+ selectedSchemaName={selectedSchemaName}
+ onSelectedSchemaNameChange={handleSchemaNameChange}
+ />
+ )}
+ {currentTab?.type === "table" && (
+ <TableEditor
+ db={currentTab.database}
+ database={currentTab.metadata.database}
+ schema={currentTab.metadata.schema}
+ table={currentTab.metadata.table}
+ />
+ )}
+ {currentTab?.type === "view" && (
+ <ViewEditor
+ db={currentTab.database}
+ database={currentTab.metadata.database}
+ schema={currentTab.metadata.schema}
+ view={currentTab.metadata.view}
+ />
+ )}
+ {currentTab?.type === "procedure" && (
+ <ProcedureEditor
+ db={currentTab.database}
+ database={currentTab.metadata.database}
+ schema={currentTab.metadata.schema}
+ procedure={currentTab.metadata.procedure}
+ />
+ )}
+ {currentTab?.type === "function" && (
+ <FunctionEditor
+ db={currentTab.database}
+ database={currentTab.metadata.database}
+ schema={currentTab.metadata.schema}
+ func={currentTab.metadata.function}
+ />
+ )}
+ </div>
+ </main>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Modals/ActionConfirmDialog.tsx b/frontend/src/react/components/SchemaEditorLite/Modals/ActionConfirmDialog.tsx
new file mode 100644
index 0000000000..99407c3bd4
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Modals/ActionConfirmDialog.tsx
@@ -0,0 +1,46 @@
+import { useTranslation } from "react-i18next";
+import {
+ AlertDialog,
+ AlertDialogContent,
+ AlertDialogDescription,
+ AlertDialogFooter,
+ AlertDialogTitle,
+} from "@/react/components/ui/alert-dialog";
+import { Button } from "@/react/components/ui/button";
+
+interface Props {
+ open: boolean;
+ onClose: () => void;
+ onConfirm: () => void;
+ title: string;
+ description?: string;
+}
+
+export function ActionConfirmDialog({
+ open,
+ onClose,
+ onConfirm,
+ title,
+ description,
+}: Props) {
+ const { t } = useTranslation();
+
+ return (
+ <AlertDialog open={open} onOpenChange={(next) => !next && onClose()}>
+ <AlertDialogContent>
+ <AlertDialogTitle>{title}</AlertDialogTitle>
+ {description && (
+ <AlertDialogDescription>{description}</AlertDialogDescription>
+ )}
+ <AlertDialogFooter>
+ <Button variant="outline" onClick={onClose}>
+ {t("common.cancel")}
+ </Button>
+ <Button variant="destructive" onClick={onConfirm}>
+ {t("common.confirm")}
+ </Button>
+ </AlertDialogFooter>
+ </AlertDialogContent>
+ </AlertDialog>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Modals/EditColumnForeignKeySheet.tsx b/frontend/src/react/components/SchemaEditorLite/Modals/EditColumnForeignKeySheet.tsx
new file mode 100644
index 0000000000..0b190ba002
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Modals/EditColumnForeignKeySheet.tsx
@@ -0,0 +1,264 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import {
+ removeColumnFromForeignKey,
+ upsertColumnFromForeignKey,
+} from "@/components/SchemaEditorLite/edit";
+import { Button } from "@/react/components/ui/button";
+import { Combobox } from "@/react/components/ui/combobox";
+import { Input } from "@/react/components/ui/input";
+import {
+ Sheet,
+ SheetContent,
+ SheetFooter,
+ SheetHeader,
+ SheetTitle,
+} from "@/react/components/ui/sheet";
+import type {
+ ColumnMetadata,
+ Database,
+ DatabaseMetadata,
+ ForeignKeyMetadata,
+ SchemaMetadata,
+ TableMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { getDatabaseEngine, hasSchemaProperty } from "@/utils";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ open: boolean;
+ onClose: () => void;
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ foreignKey?: ForeignKeyMetadata;
+}
+
+export function EditColumnForeignKeySheet({
+ open,
+ onClose,
+ db,
+ database,
+ schema,
+ table,
+ column,
+ foreignKey,
+}: Props) {
+ const { t } = useTranslation();
+ const { editStatus } = useSchemaEditorContext();
+ const engine = getDatabaseEngine(db);
+ const showSchemaSelector = hasSchemaProperty(engine);
+
+ const [fkName, setFkName] = useState("");
+ const [refSchemaName, setRefSchemaName] = useState("");
+ const [refTableName, setRefTableName] = useState<string | null>(null);
+ const [refColumnName, setRefColumnName] = useState<string | null>(null);
+
+ // Initialize from existing FK
+ useEffect(() => {
+ if (!foreignKey) {
+ setFkName(`fk_${table.name}_${column.name}`);
+ setRefSchemaName(schema.name);
+ return;
+ }
+ setFkName(foreignKey.name);
+ setRefSchemaName(foreignKey.referencedSchema || schema.name);
+ setRefTableName(foreignKey.referencedTable || null);
+
+ const position = foreignKey.columns.indexOf(column.name);
+ if (position >= 0 && foreignKey.referencedColumns[position]) {
+ setRefColumnName(foreignKey.referencedColumns[position]);
+ }
+ }, [foreignKey, table.name, column.name, schema.name]);
+
+ // Cascading options
+ const schemaOptions = useMemo(
+ () => database.schemas.map((s) => ({ label: s.name, value: s.name })),
+ [database.schemas]
+ );
+
+ const refSchema = useMemo(
+ () => database.schemas.find((s) => s.name === refSchemaName),
+ [database.schemas, refSchemaName]
+ );
+
+ const tableOptions = useMemo(
+ () =>
+ refSchema?.tables.map((t) => ({ label: t.name, value: t.name })) ?? [],
+ [refSchema]
+ );
+
+ const refTable = useMemo(
+ () => refSchema?.tables.find((t) => t.name === refTableName),
+ [refSchema, refTableName]
+ );
+
+ const columnOptions = useMemo(
+ () =>
+ refTable?.columns.map((c) => ({ label: c.name, value: c.name })) ?? [],
+ [refTable]
+ );
+
+ const allowConfirm = fkName.length > 0 && refColumnName !== null;
+
+ const handleSchemaChange = useCallback((val: string) => {
+ setRefSchemaName(val);
+ setRefTableName(null);
+ setRefColumnName(null);
+ }, []);
+
+ const handleTableChange = useCallback((val: string | null) => {
+ setRefTableName(val);
+ setRefColumnName(null);
+ }, []);
+
+ const handleConfirm = useCallback(() => {
+ if (!allowConfirm || !refColumnName) return;
+
+ if (!foreignKey) {
+ // Create new FK
+ const fk = {
+ name: fkName,
+ columns: [column.name],
+ referencedSchema: refSchemaName,
+ referencedTable: refTableName!,
+ referencedColumns: [refColumnName],
+ } as ForeignKeyMetadata;
+ table.foreignKeys.push(fk);
+ } else {
+ // Update existing FK
+ foreignKey.name = fkName;
+ if (
+ foreignKey.referencedSchema !== refSchemaName ||
+ foreignKey.referencedTable !== refTableName
+ ) {
+ foreignKey.referencedSchema = refSchemaName;
+ foreignKey.referencedTable = refTableName!;
+ foreignKey.columns = [];
+ foreignKey.referencedColumns = [];
+ }
+ upsertColumnFromForeignKey(foreignKey, column.name, refColumnName);
+ }
+
+ const status = editStatus.getColumnStatus(db, {
+ schema,
+ table,
+ column,
+ });
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, column }, "updated");
+ }
+
+ onClose();
+ }, [
+ allowConfirm,
+ refColumnName,
+ foreignKey,
+ fkName,
+ refSchemaName,
+ refTableName,
+ column,
+ table,
+ editStatus,
+ db,
+ schema,
+ onClose,
+ ]);
+
+ const handleDelete = useCallback(() => {
+ if (!foreignKey) return;
+ removeColumnFromForeignKey(table, foreignKey, column.name);
+ // Remove FK entirely if no columns left
+ if (foreignKey.columns.length === 0) {
+ const idx = table.foreignKeys.indexOf(foreignKey);
+ if (idx >= 0) table.foreignKeys.splice(idx, 1);
+ }
+ const status = editStatus.getColumnStatus(db, {
+ schema,
+ table,
+ column,
+ });
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, column }, "updated");
+ }
+ onClose();
+ }, [foreignKey, table, column, editStatus, db, schema, onClose]);
+
+ return (
+ <Sheet open={open} onOpenChange={(next) => !next && onClose()}>
+ <SheetContent width="wide">
+ <SheetHeader>
+ <SheetTitle>
+ {foreignKey
+ ? t("schema-editor.edit-foreign-key")
+ : t("schema-editor.create-foreign-key")}
+ </SheetTitle>
+ </SheetHeader>
+ <div className="flex flex-col gap-y-4 py-4">
+ <div>
+ <label className="mb-1 block text-sm font-medium">
+ {t("schema-editor.foreign-key.name")}
+ </label>
+ <Input value={fkName} onChange={(e) => setFkName(e.target.value)} />
+ </div>
+ {showSchemaSelector && (
+ <div>
+ <label className="mb-1 block text-sm font-medium">
+ {t("schema-editor.foreign-key.referenced-schema")}
+ </label>
+ <Combobox
+ value={refSchemaName}
+ onChange={(val) => handleSchemaChange(val as string)}
+ options={schemaOptions}
+ portal
+ />
+ </div>
+ )}
+ <div>
+ <label className="mb-1 block text-sm font-medium">
+ {t("schema-editor.foreign-key.referenced-table")}
+ </label>
+ <Combobox
+ value={refTableName ?? ""}
+ onChange={(val) => handleTableChange((val as string) || null)}
+ options={tableOptions}
+ portal
+ />
+ </div>
+ <div>
+ <label className="mb-1 block text-sm font-medium">
+ {t("schema-editor.foreign-key.referenced-column")}
+ </label>
+ <Combobox
+ value={refColumnName ?? ""}
+ onChange={(val) => setRefColumnName((val as string) || null)}
+ options={columnOptions}
+ portal
+ />
+ </div>
+ </div>
+ <SheetFooter>
+ <div className="flex w-full items-center justify-between">
+ <div>
+ {foreignKey && (
+ <Button variant="destructive" onClick={handleDelete}>
+ {t("common.delete")}
+ </Button>
+ )}
+ </div>
+ <div className="flex items-center gap-x-2">
+ <Button variant="outline" onClick={onClose}>
+ {t("common.cancel")}
+ </Button>
+ <Button disabled={!allowConfirm} onClick={handleConfirm}>
+ {t("common.save")}
+ </Button>
+ </div>
+ </div>
+ </SheetFooter>
+ </SheetContent>
+ </Sheet>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Modals/FunctionNameDialog.tsx b/frontend/src/react/components/SchemaEditorLite/Modals/FunctionNameDialog.tsx
new file mode 100644
index 0000000000..ec6dda86c3
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Modals/FunctionNameDialog.tsx
@@ -0,0 +1,115 @@
+import { create } from "@bufbuild/protobuf";
+import { useCallback, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import {
+ Dialog,
+ DialogContent,
+ DialogTitle,
+} from "@/react/components/ui/dialog";
+import { Input } from "@/react/components/ui/input";
+import type {
+ Database,
+ DatabaseMetadata,
+ FunctionMetadata,
+ SchemaMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { FunctionMetadataSchema } from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ open: boolean;
+ onClose: () => void;
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ func?: FunctionMetadata;
+}
+
+export function FunctionNameDialog({
+ open,
+ onClose,
+ db,
+ database,
+ schema,
+ func,
+}: Props) {
+ const { t } = useTranslation();
+ const { tabs, editStatus, rebuildTree } = useSchemaEditorContext();
+
+ const [name, setName] = useState(func?.name ?? "");
+ const isCreateMode = !func;
+
+ const isDuplicate =
+ name !== func?.name && schema.functions.some((f) => f.name === name);
+ const isValid = name.length > 0 && !isDuplicate;
+
+ const handleConfirm = useCallback(() => {
+ if (!isValid) return;
+ if (isCreateMode) {
+ const newFunc = create(FunctionMetadataSchema, {
+ name,
+ definition: "",
+ }) as FunctionMetadata;
+ schema.functions.push(newFunc);
+ editStatus.markEditStatus(db, { schema, function: newFunc }, "created");
+ tabs.addTab({
+ type: "function",
+ database: db,
+ metadata: { database, schema, function: newFunc },
+ });
+ rebuildTree(false);
+ } else {
+ func.name = name;
+ }
+ onClose();
+ }, [
+ isValid,
+ isCreateMode,
+ name,
+ schema,
+ editStatus,
+ db,
+ database,
+ tabs,
+ rebuildTree,
+ func,
+ onClose,
+ ]);
+
+ return (
+ <Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+ <DialogContent>
+ <DialogTitle>
+ {isCreateMode
+ ? t("schema-editor.actions.create-function")
+ : t("schema-editor.actions.rename")}
+ </DialogTitle>
+ <div className="mt-4 flex flex-col gap-y-4">
+ <Input
+ value={name}
+ placeholder="Function name"
+ autoFocus
+ onChange={(e) => setName(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === "Enter") handleConfirm();
+ }}
+ />
+ {isDuplicate && (
+ <p className="text-xs text-error">
+ {t("schema-editor.table.duplicate-name")}
+ </p>
+ )}
+ <div className="flex items-center justify-end gap-x-2">
+ <Button variant="outline" onClick={onClose}>
+ {t("common.cancel")}
+ </Button>
+ <Button disabled={!isValid} onClick={handleConfirm}>
+ {isCreateMode ? t("common.create") : t("common.save")}
+ </Button>
+ </div>
+ </div>
+ </DialogContent>
+ </Dialog>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Modals/ProcedureNameDialog.tsx b/frontend/src/react/components/SchemaEditorLite/Modals/ProcedureNameDialog.tsx
new file mode 100644
index 0000000000..02dc592899
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Modals/ProcedureNameDialog.tsx
@@ -0,0 +1,115 @@
+import { create } from "@bufbuild/protobuf";
+import { useCallback, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import {
+ Dialog,
+ DialogContent,
+ DialogTitle,
+} from "@/react/components/ui/dialog";
+import { Input } from "@/react/components/ui/input";
+import type {
+ Database,
+ DatabaseMetadata,
+ ProcedureMetadata,
+ SchemaMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { ProcedureMetadataSchema } from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ open: boolean;
+ onClose: () => void;
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ procedure?: ProcedureMetadata;
+}
+
+export function ProcedureNameDialog({
+ open,
+ onClose,
+ db,
+ database,
+ schema,
+ procedure,
+}: Props) {
+ const { t } = useTranslation();
+ const { tabs, editStatus, rebuildTree } = useSchemaEditorContext();
+
+ const [name, setName] = useState(procedure?.name ?? "");
+ const isCreateMode = !procedure;
+
+ const isDuplicate =
+ name !== procedure?.name && schema.procedures.some((p) => p.name === name);
+ const isValid = name.length > 0 && !isDuplicate;
+
+ const handleConfirm = useCallback(() => {
+ if (!isValid) return;
+ if (isCreateMode) {
+ const newProc = create(ProcedureMetadataSchema, {
+ name,
+ definition: "",
+ }) as ProcedureMetadata;
+ schema.procedures.push(newProc);
+ editStatus.markEditStatus(db, { schema, procedure: newProc }, "created");
+ tabs.addTab({
+ type: "procedure",
+ database: db,
+ metadata: { database, schema, procedure: newProc },
+ });
+ rebuildTree(false);
+ } else {
+ procedure.name = name;
+ }
+ onClose();
+ }, [
+ isValid,
+ isCreateMode,
+ name,
+ schema,
+ editStatus,
+ db,
+ database,
+ tabs,
+ rebuildTree,
+ procedure,
+ onClose,
+ ]);
+
+ return (
+ <Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+ <DialogContent>
+ <DialogTitle>
+ {isCreateMode
+ ? t("schema-editor.actions.create-procedure")
+ : t("schema-editor.actions.rename")}
+ </DialogTitle>
+ <div className="mt-4 flex flex-col gap-y-4">
+ <Input
+ value={name}
+ placeholder="Procedure name"
+ autoFocus
+ onChange={(e) => setName(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === "Enter") handleConfirm();
+ }}
+ />
+ {isDuplicate && (
+ <p className="text-xs text-error">
+ {t("schema-editor.table.duplicate-name")}
+ </p>
+ )}
+ <div className="flex items-center justify-end gap-x-2">
+ <Button variant="outline" onClick={onClose}>
+ {t("common.cancel")}
+ </Button>
+ <Button disabled={!isValid} onClick={handleConfirm}>
+ {isCreateMode ? t("common.create") : t("common.save")}
+ </Button>
+ </div>
+ </div>
+ </DialogContent>
+ </Dialog>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Modals/SchemaNameDialog.tsx b/frontend/src/react/components/SchemaEditorLite/Modals/SchemaNameDialog.tsx
new file mode 100644
index 0000000000..bd5eed9c19
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Modals/SchemaNameDialog.tsx
@@ -0,0 +1,105 @@
+import { create } from "@bufbuild/protobuf";
+import { useCallback, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import {
+ Dialog,
+ DialogContent,
+ DialogTitle,
+} from "@/react/components/ui/dialog";
+import { Input } from "@/react/components/ui/input";
+import type {
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { SchemaMetadataSchema } from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ open: boolean;
+ onClose: () => void;
+ db: Database;
+ database: DatabaseMetadata;
+ schema?: SchemaMetadata;
+}
+
+export function SchemaNameDialog({
+ open,
+ onClose,
+ db,
+ database,
+ schema,
+}: Props) {
+ const { t } = useTranslation();
+ const { editStatus, rebuildTree } = useSchemaEditorContext();
+
+ const [schemaName, setSchemaName] = useState(schema?.name ?? "");
+ const isCreateMode = !schema;
+
+ const isDuplicate =
+ schemaName !== schema?.name &&
+ database.schemas.some((s) => s.name === schemaName);
+
+ const isValid = schemaName.length > 0 && !isDuplicate;
+
+ const handleConfirm = useCallback(() => {
+ if (!isValid) return;
+
+ if (isCreateMode) {
+ const newSchema = create(SchemaMetadataSchema, {
+ name: schemaName,
+ tables: [],
+ views: [],
+ procedures: [],
+ functions: [],
+ });
+ database.schemas.push(newSchema);
+ editStatus.markEditStatus(db, { schema: newSchema }, "created");
+ rebuildTree(false);
+ }
+
+ onClose();
+ }, [
+ isValid,
+ isCreateMode,
+ schemaName,
+ database,
+ editStatus,
+ db,
+ rebuildTree,
+ onClose,
+ ]);
+
+ return (
+ <Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+ <DialogContent>
+ <DialogTitle>{t("schema-editor.actions.create-schema")}</DialogTitle>
+ <div className="mt-4 flex flex-col gap-y-4">
+ <Input
+ value={schemaName}
+ placeholder={t("schema-editor.schema.name-placeholder")}
+ autoFocus
+ onChange={(e) => setSchemaName(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === "Enter") handleConfirm();
+ }}
+ />
+ {isDuplicate && (
+ <p className="text-xs text-error">
+ {t("schema-editor.schema.duplicate-name")}
+ </p>
+ )}
+ <div className="flex items-center justify-end gap-x-2">
+ <Button variant="outline" onClick={onClose}>
+ {t("common.cancel")}
+ </Button>
+ <Button disabled={!isValid} onClick={handleConfirm}>
+ {t("common.create")}
+ </Button>
+ </div>
+ </div>
+ </DialogContent>
+ </Dialog>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Modals/TableNameDialog.tsx b/frontend/src/react/components/SchemaEditorLite/Modals/TableNameDialog.tsx
new file mode 100644
index 0000000000..4e7515a4dd
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Modals/TableNameDialog.tsx
@@ -0,0 +1,162 @@
+import { create } from "@bufbuild/protobuf";
+import { useCallback, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { upsertColumnPrimaryKey } from "@/components/SchemaEditorLite/edit";
+import { Button } from "@/react/components/ui/button";
+import {
+ Dialog,
+ DialogContent,
+ DialogTitle,
+} from "@/react/components/ui/dialog";
+import { Input } from "@/react/components/ui/input";
+import { Engine } from "@/types/proto-es/v1/common_pb";
+import type {
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+ TableMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import {
+ ColumnMetadataSchema,
+ TableMetadataSchema,
+} from "@/types/proto-es/v1/database_service_pb";
+import { getDatabaseEngine } from "@/utils";
+import { useSchemaEditorContext } from "../context";
+import { markUUID } from "../Panels/common";
+
+interface Props {
+ open: boolean;
+ onClose: () => void;
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table?: TableMetadata;
+}
+
+const TABLE_NAME_REGEX = /^\S[\S ]*\S?$/;
+
+export function TableNameDialog({
+ open,
+ onClose,
+ db,
+ database,
+ schema,
+ table,
+}: Props) {
+ const { t } = useTranslation();
+ const { tabs, editStatus, rebuildTree, rebuildEditStatus, scrollStatus } =
+ useSchemaEditorContext();
+ const engine = getDatabaseEngine(db);
+
+ const [tableName, setTableName] = useState(table?.name ?? "");
+ const isCreateMode = !table;
+
+ const isDuplicate =
+ tableName !== table?.name &&
+ schema.tables.some((t) => t.name === tableName);
+
+ const isValid =
+ tableName.length > 0 && TABLE_NAME_REGEX.test(tableName) && !isDuplicate;
+
+ const handleConfirm = useCallback(() => {
+ if (!isValid) return;
+
+ if (isCreateMode) {
+ const newTable = create(TableMetadataSchema, {
+ name: tableName,
+ columns: [],
+ indexes: [],
+ foreignKeys: [],
+ partitions: [],
+ comment: "",
+ });
+ schema.tables.push(newTable);
+ editStatus.markEditStatus(db, { schema, table: newTable }, "created");
+
+ const defaultType = engine === Engine.POSTGRES ? "integer" : "int";
+ const idColumn = create(ColumnMetadataSchema, {
+ name: "id",
+ type: defaultType,
+ nullable: false,
+ hasDefault: false,
+ default: "",
+ comment: "",
+ });
+ markUUID(idColumn);
+ newTable.columns.push(idColumn);
+ editStatus.markEditStatus(
+ db,
+ { schema, table: newTable, column: idColumn },
+ "created"
+ );
+ upsertColumnPrimaryKey(engine, newTable, "id");
+
+ tabs.addTab({
+ type: "table",
+ database: db,
+ metadata: { database, schema, table: newTable },
+ });
+ scrollStatus.queuePendingScrollToTable({
+ db,
+ metadata: { database, schema, table: newTable },
+ });
+ rebuildTree(false);
+ } else {
+ table.name = tableName;
+ rebuildEditStatus(["tree"]);
+ }
+
+ onClose();
+ }, [
+ isValid,
+ isCreateMode,
+ tableName,
+ schema,
+ editStatus,
+ db,
+ database,
+ engine,
+ tabs,
+ scrollStatus,
+ rebuildTree,
+ rebuildEditStatus,
+ table,
+ onClose,
+ ]);
+
+ return (
+ <Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+ <DialogContent>
+ <DialogTitle>
+ {isCreateMode
+ ? t("schema-editor.actions.create-table")
+ : t("schema-editor.actions.rename-table")}
+ </DialogTitle>
+ <div className="mt-4 flex flex-col gap-y-4">
+ <Input
+ value={tableName}
+ placeholder={t("schema-editor.table.name-placeholder")}
+ autoFocus
+ onChange={(e) => setTableName(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === "Enter") handleConfirm();
+ }}
+ />
+ {isDuplicate && (
+ <p className="text-xs text-error">
+ {t("schema-editor.table.duplicate-name")}
+ </p>
+ )}
+ <div className="flex items-center justify-end gap-x-2">
+ <Button variant="outline" onClick={onClose}>
+ {t("common.cancel")}
+ </Button>
+ <Button disabled={!isValid} onClick={handleConfirm}>
+ {isCreateMode ? t("common.create") : t("common.save")}
+ </Button>
+ </div>
+ </div>
+ </DialogContent>
+ </Dialog>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Modals/ViewNameDialog.tsx b/frontend/src/react/components/SchemaEditorLite/Modals/ViewNameDialog.tsx
new file mode 100644
index 0000000000..fa80d9dd0f
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Modals/ViewNameDialog.tsx
@@ -0,0 +1,115 @@
+import { create } from "@bufbuild/protobuf";
+import { useCallback, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import {
+ Dialog,
+ DialogContent,
+ DialogTitle,
+} from "@/react/components/ui/dialog";
+import { Input } from "@/react/components/ui/input";
+import type {
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+ ViewMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { ViewMetadataSchema } from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ open: boolean;
+ onClose: () => void;
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ view?: ViewMetadata;
+}
+
+export function ViewNameDialog({
+ open,
+ onClose,
+ db,
+ database,
+ schema,
+ view,
+}: Props) {
+ const { t } = useTranslation();
+ const { tabs, editStatus, rebuildTree } = useSchemaEditorContext();
+
+ const [name, setName] = useState(view?.name ?? "");
+ const isCreateMode = !view;
+
+ const isDuplicate =
+ name !== view?.name && schema.views.some((v) => v.name === name);
+ const isValid = name.length > 0 && !isDuplicate;
+
+ const handleConfirm = useCallback(() => {
+ if (!isValid) return;
+ if (isCreateMode) {
+ const newView = create(ViewMetadataSchema, {
+ name,
+ definition: "",
+ }) as ViewMetadata;
+ schema.views.push(newView);
+ editStatus.markEditStatus(db, { schema, view: newView }, "created");
+ tabs.addTab({
+ type: "view",
+ database: db,
+ metadata: { database, schema, view: newView },
+ });
+ rebuildTree(false);
+ } else {
+ view.name = name;
+ }
+ onClose();
+ }, [
+ isValid,
+ isCreateMode,
+ name,
+ schema,
+ editStatus,
+ db,
+ database,
+ tabs,
+ rebuildTree,
+ view,
+ onClose,
+ ]);
+
+ return (
+ <Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+ <DialogContent>
+ <DialogTitle>
+ {isCreateMode
+ ? t("schema-editor.actions.create-view")
+ : t("schema-editor.actions.rename")}
+ </DialogTitle>
+ <div className="mt-4 flex flex-col gap-y-4">
+ <Input
+ value={name}
+ placeholder="View name"
+ autoFocus
+ onChange={(e) => setName(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === "Enter") handleConfirm();
+ }}
+ />
+ {isDuplicate && (
+ <p className="text-xs text-error">
+ {t("schema-editor.table.duplicate-name")}
+ </p>
+ )}
+ <div className="flex items-center justify-end gap-x-2">
+ <Button variant="outline" onClick={onClose}>
+ {t("common.cancel")}
+ </Button>
+ <Button disabled={!isValid} onClick={handleConfirm}>
+ {isCreateMode ? t("common.create") : t("common.save")}
+ </Button>
+ </div>
+ </div>
+ </DialogContent>
+ </Dialog>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/DatabaseEditor.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/DatabaseEditor.tsx
new file mode 100644
index 0000000000..e98a26e5bd
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/DatabaseEditor.tsx
@@ -0,0 +1,143 @@
+import { Plus } from "lucide-react";
+import { useCallback, useEffect, useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import { Combobox } from "@/react/components/ui/combobox";
+import type {
+ Database,
+ DatabaseMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { getDatabaseEngine, hasSchemaProperty } from "@/utils";
+import { useSchemaEditorContext } from "../context";
+import { TableList } from "./TableList";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ selectedSchemaName: string | undefined;
+ onSelectedSchemaNameChange: (name: string | undefined) => void;
+ searchPattern?: string;
+}
+
+export function DatabaseEditor({
+ db,
+ database,
+ selectedSchemaName,
+ onSelectedSchemaNameChange,
+ searchPattern,
+}: Props) {
+ const { t } = useTranslation();
+ const { readonly, tabs, editStatus } = useSchemaEditorContext();
+ const engine = getDatabaseEngine(db);
+
+ const shouldShowSchemaSelector = hasSchemaProperty(engine);
+
+ const schemaOptions = useMemo(() => {
+ return database.schemas.map((s) => ({
+ label: s.name,
+ value: s.name,
+ }));
+ }, [database.schemas]);
+
+ const selectedSchema = useMemo(() => {
+ return database.schemas.find((s) => s.name === selectedSchemaName);
+ }, [database.schemas, selectedSchemaName]);
+
+ // Auto-select first schema if current selection is invalid
+ useEffect(() => {
+ if (!shouldShowSchemaSelector) return;
+ if (
+ selectedSchemaName &&
+ database.schemas.some((s) => s.name === selectedSchemaName)
+ ) {
+ return;
+ }
+ if (database.schemas.length > 0) {
+ onSelectedSchemaNameChange(database.schemas[0].name);
+ }
+ }, [
+ shouldShowSchemaSelector,
+ selectedSchemaName,
+ database.schemas,
+ onSelectedSchemaNameChange,
+ ]);
+
+ // For single-schema engines, use the first (and only) schema
+ const effectiveSchema = useMemo(() => {
+ if (shouldShowSchemaSelector) return selectedSchema;
+ return database.schemas[0];
+ }, [shouldShowSchemaSelector, selectedSchema, database.schemas]);
+
+ const allowCreateTable = useMemo(() => {
+ if (!effectiveSchema) return false;
+ const status = editStatus.getSchemaStatus(db, {
+ schema: effectiveSchema,
+ });
+ return status !== "dropped";
+ }, [effectiveSchema, editStatus, db]);
+
+ const handleEditTable = useCallback(
+ (table: { name: string }) => {
+ if (!effectiveSchema) return;
+ const tableMetadata = effectiveSchema.tables.find(
+ (t) => t.name === table.name
+ );
+ if (!tableMetadata) return;
+ tabs.addTab({
+ type: "table",
+ database: db,
+ metadata: {
+ database,
+ schema: effectiveSchema,
+ table: tableMetadata,
+ },
+ });
+ },
+ [effectiveSchema, tabs, db, database]
+ );
+
+ if (!effectiveSchema) {
+ return (
+ <div className="flex size-full items-center justify-center text-sm text-control-light">
+ No schema available
+ </div>
+ );
+ }
+
+ return (
+ <div className="flex size-full flex-col overflow-y-hidden">
+ <div className="flex items-center gap-x-2 border-b border-control-border px-4 py-2">
+ {shouldShowSchemaSelector && (
+ <Combobox
+ value={selectedSchemaName ?? ""}
+ onChange={(val) => onSelectedSchemaNameChange(val as string)}
+ options={schemaOptions}
+ className="w-48"
+ />
+ )}
+ {!readonly && allowCreateTable && (
+ <Button
+ variant="outline"
+ size="sm"
+ onClick={() => {
+ // Will be wired to TableNameDialog in T22
+ }}
+ >
+ <Plus className="mr-1 size-4" />
+ {t("schema-editor.actions.create-table")}
+ </Button>
+ )}
+ </div>
+ <div className="flex-1 overflow-y-auto">
+ <TableList
+ db={db}
+ database={database}
+ schema={effectiveSchema}
+ tables={effectiveSchema.tables}
+ searchPattern={searchPattern}
+ onEditTable={handleEditTable}
+ />
+ </div>
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/FunctionEditor.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/FunctionEditor.tsx
new file mode 100644
index 0000000000..9e0df72c11
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/FunctionEditor.tsx
@@ -0,0 +1,69 @@
+import { useCallback, useMemo } from "react";
+import { MonacoEditor } from "@/react/components/monaco/MonacoEditor";
+import type {
+ Database,
+ DatabaseMetadata,
+ FunctionMetadata,
+ SchemaMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { languageOfEngineV1 } from "@/types/sqlEditor/editor";
+import { getDatabaseEngine } from "@/utils";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ func: FunctionMetadata;
+}
+
+export function FunctionEditor({
+ db,
+ database: _database,
+ schema,
+ func,
+}: Props) {
+ const { readonly, editStatus } = useSchemaEditorContext();
+ const engine = getDatabaseEngine(db);
+ const language = languageOfEngineV1(engine);
+
+ const status = useMemo(
+ () => editStatus.getFunctionStatus(db, { schema, function: func }),
+ [editStatus, db, schema, func]
+ );
+
+ const schemaStatus = useMemo(
+ () => editStatus.getSchemaStatus(db, { schema }),
+ [editStatus, db, schema]
+ );
+
+ const disallowChange =
+ readonly || schemaStatus === "dropped" || status === "dropped";
+
+ const handleUpdateDefinition = useCallback(
+ (code: string) => {
+ func.definition = code;
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, function: func }, "updated");
+ }
+ },
+ [func, status, editStatus, db, schema]
+ );
+
+ return (
+ <div className="flex size-full flex-col">
+ <MonacoEditor
+ content={func.definition}
+ language={language}
+ readOnly={disallowChange}
+ className="flex-1"
+ options={{
+ minimap: { enabled: false },
+ lineNumbers: "on",
+ scrollBeyondLastLine: false,
+ }}
+ onChange={handleUpdateDefinition}
+ />
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/IndexesEditor/IndexesEditor.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/IndexesEditor/IndexesEditor.tsx
new file mode 100644
index 0000000000..8e70992bbf
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/IndexesEditor/IndexesEditor.tsx
@@ -0,0 +1,181 @@
+import { create } from "@bufbuild/protobuf";
+import { Plus, Trash2 } from "lucide-react";
+import { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import { Combobox } from "@/react/components/ui/combobox";
+import { Input } from "@/react/components/ui/input";
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from "@/react/components/ui/table";
+import type {
+ Database,
+ DatabaseMetadata,
+ IndexMetadata,
+ SchemaMetadata,
+ TableMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { IndexMetadataSchema } from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../../context";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ readonly: boolean;
+}
+
+export function IndexesEditor({
+ db,
+ database: _database,
+ schema,
+ table,
+ readonly: isReadonly,
+}: Props) {
+ const { t } = useTranslation();
+ const { editStatus } = useSchemaEditorContext();
+
+ const columnOptions = table.columns.map((col) => ({
+ label: col.name,
+ value: col.name,
+ }));
+
+ const handleAddIndex = useCallback(() => {
+ const index = create(IndexMetadataSchema, {
+ name: `idx_${table.name}_${Date.now()}`,
+ expressions: [],
+ primary: false,
+ unique: false,
+ comment: "",
+ });
+ table.indexes.push(index);
+ editStatus.markEditStatus(db, { schema, table }, "updated");
+ }, [table, editStatus, db, schema]);
+
+ const handleDropIndex = useCallback(
+ (index: IndexMetadata) => {
+ const idx = table.indexes.indexOf(index);
+ if (idx >= 0) table.indexes.splice(idx, 1);
+ editStatus.markEditStatus(db, { schema, table }, "updated");
+ },
+ [table, editStatus, db, schema]
+ );
+
+ const handleIndexChange = useCallback(() => {
+ editStatus.markEditStatus(db, { schema, table }, "updated");
+ }, [editStatus, db, schema, table]);
+
+ return (
+ <div className="flex size-full flex-col gap-y-2 overflow-auto">
+ {!isReadonly && (
+ <div>
+ <Button variant="outline" size="sm" onClick={handleAddIndex}>
+ <Plus className="mr-1 size-4" />
+ {t("schema-editor.actions.add-index")}
+ </Button>
+ </div>
+ )}
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead className="w-[180px]">
+ {t("schema-editor.column.name")}
+ </TableHead>
+ <TableHead className="w-[200px]">
+ {t("schema-editor.index.columns")}
+ </TableHead>
+ <TableHead className="w-[100px]">
+ {t("schema-editor.column.comment")}
+ </TableHead>
+ <TableHead className="w-16 text-center">
+ {t("schema-editor.index.unique")}
+ </TableHead>
+ <TableHead className="w-16 text-center">
+ {t("schema-editor.index.primary")}
+ </TableHead>
+ {!isReadonly && (
+ <TableHead className="w-16 text-right">
+ {t("schema-editor.column.operations")}
+ </TableHead>
+ )}
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {table.indexes.map((index, i) => (
+ <TableRow key={`${index.name}-${i}`}>
+ <TableCell>
+ <Input
+ value={index.name}
+ disabled={isReadonly || index.primary}
+ className="h-7 border-none bg-transparent shadow-none focus-visible:ring-1"
+ onChange={(e) => {
+ index.name = e.target.value;
+ handleIndexChange();
+ }}
+ />
+ </TableCell>
+ <TableCell>
+ <Combobox
+ multiple
+ value={[...index.expressions]}
+ onChange={(val) => {
+ index.expressions = val as string[];
+ handleIndexChange();
+ }}
+ options={columnOptions}
+ disabled={isReadonly}
+ className="h-7"
+ />
+ </TableCell>
+ <TableCell>
+ <Input
+ value={index.comment}
+ disabled={isReadonly}
+ className="h-7 border-none bg-transparent shadow-none focus-visible:ring-1"
+ onChange={(e) => {
+ index.comment = e.target.value;
+ handleIndexChange();
+ }}
+ />
+ </TableCell>
+ <TableCell className="text-center">
+ <input
+ type="checkbox"
+ checked={index.unique}
+ disabled={isReadonly || index.primary}
+ onChange={(e) => {
+ index.unique = e.target.checked;
+ handleIndexChange();
+ }}
+ />
+ </TableCell>
+ <TableCell className="text-center">
+ <input type="checkbox" checked={index.primary} disabled />
+ </TableCell>
+ {!isReadonly && (
+ <TableCell className="text-right">
+ {!index.primary && (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 p-0 text-error hover:text-error"
+ onClick={() => handleDropIndex(index)}
+ >
+ <Trash2 className="size-3.5" />
+ </Button>
+ )}
+ </TableCell>
+ )}
+ </TableRow>
+ ))}
+ </TableBody>
+ </Table>
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/IndexesEditor/index.ts b/frontend/src/react/components/SchemaEditorLite/Panels/IndexesEditor/index.ts
new file mode 100644
index 0000000000..132f7e85ca
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/IndexesEditor/index.ts
@@ -0,0 +1 @@
+export { IndexesEditor } from "./IndexesEditor";
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/PartitionsEditor/PartitionsEditor.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/PartitionsEditor/PartitionsEditor.tsx
new file mode 100644
index 0000000000..5ad187407a
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/PartitionsEditor/PartitionsEditor.tsx
@@ -0,0 +1,231 @@
+import { create } from "@bufbuild/protobuf";
+import { Plus, RotateCcw, Trash2 } from "lucide-react";
+import { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import { Input } from "@/react/components/ui/input";
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from "@/react/components/ui/table";
+import { cn } from "@/react/lib/utils";
+import type {
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+ TableMetadata,
+ TablePartitionMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import {
+ TablePartitionMetadata_Type,
+ TablePartitionMetadataSchema,
+} from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../../context";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ readonly: boolean;
+}
+
+export function PartitionsEditor({
+ db,
+ database: _database,
+ schema,
+ table,
+ readonly: isReadonly,
+}: Props) {
+ const { t } = useTranslation();
+ const { editStatus } = useSchemaEditorContext();
+
+ const handleAddPartition = useCallback(() => {
+ const firstPartition = table.partitions[0];
+ const partition = create(TablePartitionMetadataSchema, {
+ name: `p${table.partitions.length}`,
+ type: firstPartition?.type ?? TablePartitionMetadata_Type.RANGE,
+ expression: firstPartition?.expression ?? "",
+ value: "",
+ subpartitions: [],
+ });
+ table.partitions.push(partition);
+ editStatus.markEditStatus(db, { schema, table }, "updated");
+ }, [table, editStatus, db, schema]);
+
+ const handleDropPartition = useCallback(
+ (partition: TablePartitionMetadata) => {
+ const status = editStatus.getPartitionStatus(db, {
+ schema,
+ table,
+ partition,
+ });
+ if (status === "created") {
+ const idx = table.partitions.indexOf(partition);
+ if (idx >= 0) table.partitions.splice(idx, 1);
+ editStatus.removeEditStatus(db, { schema, table, partition }, true);
+ } else {
+ editStatus.markEditStatus(db, { schema, table, partition }, "dropped");
+ }
+ },
+ [editStatus, db, schema, table]
+ );
+
+ const handleRestorePartition = useCallback(
+ (partition: TablePartitionMetadata) => {
+ editStatus.removeEditStatus(db, { schema, table, partition }, false);
+ },
+ [editStatus, db, schema, table]
+ );
+
+ const handlePartitionChange = useCallback(
+ (partition: TablePartitionMetadata) => {
+ const status = editStatus.getPartitionStatus(db, {
+ schema,
+ table,
+ partition,
+ });
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, partition }, "updated");
+ }
+ },
+ [editStatus, db, schema, table]
+ );
+
+ return (
+ <div className="flex size-full flex-col gap-y-2 overflow-auto">
+ {!isReadonly && (
+ <div>
+ <Button variant="outline" size="sm" onClick={handleAddPartition}>
+ <Plus className="mr-1 size-4" />
+ {t("schema-editor.actions.add-partition")}
+ </Button>
+ </div>
+ )}
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead className="w-[160px]">
+ {t("schema-editor.column.name")}
+ </TableHead>
+ <TableHead className="w-[140px]">
+ {t("schema-editor.partition.type")}
+ </TableHead>
+ <TableHead className="w-[180px]">
+ {t("schema-editor.partition.expression")}
+ </TableHead>
+ <TableHead className="w-[140px]">
+ {t("schema-editor.partition.value")}
+ </TableHead>
+ {!isReadonly && (
+ <TableHead className="w-16 text-right">
+ {t("schema-editor.column.operations")}
+ </TableHead>
+ )}
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {table.partitions.map((partition, i) => {
+ const status = editStatus.getPartitionStatus(db, {
+ schema,
+ table,
+ partition,
+ });
+ const isFirst = i === 0;
+ return (
+ <TableRow
+ key={`${partition.name}-${i}`}
+ className={cn(
+ status === "created" && "text-success",
+ status === "updated" && "text-warning",
+ status === "dropped" && "text-error line-through"
+ )}
+ >
+ <TableCell>
+ <Input
+ value={partition.name}
+ disabled={isReadonly || status === "dropped"}
+ className="h-7 border-none bg-transparent shadow-none focus-visible:ring-1"
+ onChange={(e) => {
+ partition.name = e.target.value;
+ handlePartitionChange(partition);
+ }}
+ />
+ </TableCell>
+ <TableCell className="text-sm">
+ {partitionTypeLabel(partition.type)}
+ </TableCell>
+ <TableCell>
+ <Input
+ value={partition.expression}
+ disabled={isReadonly || !isFirst || status === "dropped"}
+ className="h-7 border-none bg-transparent shadow-none focus-visible:ring-1"
+ onChange={(e) => {
+ partition.expression = e.target.value;
+ handlePartitionChange(partition);
+ }}
+ />
+ </TableCell>
+ <TableCell>
+ <Input
+ value={partition.value}
+ disabled={isReadonly || status === "dropped"}
+ className="h-7 border-none bg-transparent shadow-none focus-visible:ring-1"
+ onChange={(e) => {
+ partition.value = e.target.value;
+ handlePartitionChange(partition);
+ }}
+ />
+ </TableCell>
+ {!isReadonly && (
+ <TableCell className="text-right">
+ {status === "dropped" ? (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 p-0"
+ onClick={() => handleRestorePartition(partition)}
+ >
+ <RotateCcw className="size-3.5" />
+ </Button>
+ ) : (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 p-0 text-error hover:text-error"
+ onClick={() => handleDropPartition(partition)}
+ >
+ <Trash2 className="size-3.5" />
+ </Button>
+ )}
+ </TableCell>
+ )}
+ </TableRow>
+ );
+ })}
+ </TableBody>
+ </Table>
+ </div>
+ );
+}
+
+function partitionTypeLabel(type: TablePartitionMetadata_Type): string {
+ switch (type) {
+ case TablePartitionMetadata_Type.RANGE:
+ return "RANGE";
+ case TablePartitionMetadata_Type.RANGE_COLUMNS:
+ return "RANGE COLUMNS";
+ case TablePartitionMetadata_Type.LIST:
+ return "LIST";
+ case TablePartitionMetadata_Type.LIST_COLUMNS:
+ return "LIST COLUMNS";
+ case TablePartitionMetadata_Type.HASH:
+ return "HASH";
+ default:
+ return String(type);
+ }
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/PartitionsEditor/index.ts b/frontend/src/react/components/SchemaEditorLite/Panels/PartitionsEditor/index.ts
new file mode 100644
index 0000000000..4805490f65
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/PartitionsEditor/index.ts
@@ -0,0 +1 @@
+export { PartitionsEditor } from "./PartitionsEditor";
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/PreviewPane.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/PreviewPane.tsx
new file mode 100644
index 0000000000..c97e03079a
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/PreviewPane.tsx
@@ -0,0 +1,149 @@
+import { create } from "@bufbuild/protobuf";
+import { cloneDeep } from "lodash-es";
+import { ChevronDown, ChevronRight, Loader2 } from "lucide-react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { databaseServiceClientConnect } from "@/connect";
+import { ReadonlyMonaco } from "@/react/components/monaco/ReadonlyMonaco";
+import type {
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+ TableMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import {
+ DatabaseMetadataSchema,
+ GetSchemaStringRequestSchema,
+} from "@/types/proto-es/v1/database_service_pb";
+import { languageOfEngineV1 } from "@/types/sqlEditor/editor";
+import { getDatabaseEngine } from "@/utils";
+import { extractGrpcErrorMessage } from "@/utils/connect";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+}
+
+const STORAGE_KEY = "bb.schema-editor.preview-expanded";
+
+export function PreviewPane({ db, database, schema, table }: Props) {
+ const { t } = useTranslation();
+ const { hidePreview, editStatus } = useSchemaEditorContext();
+ const engine = getDatabaseEngine(db);
+ const language = languageOfEngineV1(engine);
+
+ const [expanded, setExpanded] = useState(() => {
+ try {
+ return localStorage.getItem(STORAGE_KEY) !== "false";
+ } catch {
+ return true;
+ }
+ });
+
+ const [pending, setPending] = useState(false);
+ const [ddl, setDdl] = useState("");
+ const [error, setError] = useState("");
+ const fetchIdRef = useRef(0);
+
+ const toggleExpanded = useCallback(() => {
+ setExpanded((prev) => {
+ const next = !prev;
+ try {
+ localStorage.setItem(STORAGE_KEY, String(next));
+ } catch {
+ // ignore
+ }
+ return next;
+ });
+ }, []);
+
+ // Build mocked metadata (filter dropped columns, wrap in single-table DatabaseMetadata)
+ const mockedMetadata = useMemo(() => {
+ const cloned = cloneDeep(table);
+ cloned.columns = cloned.columns.filter((column) => {
+ if (!column.name) return false;
+ const status = editStatus.getColumnStatus(db, {
+ schema,
+ table,
+ column,
+ });
+ return status !== "dropped";
+ });
+ return create(DatabaseMetadataSchema, {
+ name: database.name,
+ characterSet: database.characterSet,
+ collation: database.collation,
+ schemas: [{ name: schema.name, tables: [cloned] }],
+ }) as DatabaseMetadata;
+ }, [table, editStatus, db, schema, database]);
+
+ // Fetch schema string for the mocked metadata
+ const fetchSchemaString = useCallback(async () => {
+ const id = ++fetchIdRef.current;
+ setPending(true);
+ setError("");
+ try {
+ const request = create(GetSchemaStringRequestSchema, {
+ name: `${db.name}/schemaString`,
+ metadata: mockedMetadata,
+ });
+ const response =
+ await databaseServiceClientConnect.getSchemaString(request);
+ if (id !== fetchIdRef.current) return;
+ setDdl(response.schemaString);
+ } catch (err) {
+ if (id !== fetchIdRef.current) return;
+ setError(extractGrpcErrorMessage(err));
+ } finally {
+ if (id === fetchIdRef.current) {
+ setPending(false);
+ }
+ }
+ }, [db, mockedMetadata]);
+
+ useEffect(() => {
+ if (expanded && !hidePreview) {
+ fetchSchemaString();
+ }
+ }, [expanded, hidePreview, fetchSchemaString]);
+
+ if (hidePreview) return null;
+
+ return (
+ <div className="border-t border-control-border">
+ <button
+ type="button"
+ className="flex w-full items-center gap-x-1 px-4 py-1.5 text-xs font-medium text-control-light hover:text-control"
+ onClick={toggleExpanded}
+ >
+ {expanded ? (
+ <ChevronDown className="size-3.5" />
+ ) : (
+ <ChevronRight className="size-3.5" />
+ )}
+ {t("schema-editor.preview")}
+ </button>
+ {expanded && (
+ <div className="relative h-32 overflow-hidden">
+ {pending && (
+ <div className="absolute inset-0 z-10 flex items-center justify-center bg-white/60">
+ <Loader2 className="size-5 animate-spin text-accent" />
+ </div>
+ )}
+ {error ? (
+ <pre className="p-2 text-xs text-error">{error}</pre>
+ ) : (
+ <ReadonlyMonaco
+ content={ddl}
+ language={language}
+ className="size-full"
+ />
+ )}
+ </div>
+ )}
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/ProcedureEditor.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/ProcedureEditor.tsx
new file mode 100644
index 0000000000..ceae54c2cf
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/ProcedureEditor.tsx
@@ -0,0 +1,69 @@
+import { useCallback, useMemo } from "react";
+import { MonacoEditor } from "@/react/components/monaco/MonacoEditor";
+import type {
+ Database,
+ DatabaseMetadata,
+ ProcedureMetadata,
+ SchemaMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { languageOfEngineV1 } from "@/types/sqlEditor/editor";
+import { getDatabaseEngine } from "@/utils";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ procedure: ProcedureMetadata;
+}
+
+export function ProcedureEditor({
+ db,
+ database: _database,
+ schema,
+ procedure,
+}: Props) {
+ const { readonly, editStatus } = useSchemaEditorContext();
+ const engine = getDatabaseEngine(db);
+ const language = languageOfEngineV1(engine);
+
+ const status = useMemo(
+ () => editStatus.getProcedureStatus(db, { schema, procedure }),
+ [editStatus, db, schema, procedure]
+ );
+
+ const schemaStatus = useMemo(
+ () => editStatus.getSchemaStatus(db, { schema }),
+ [editStatus, db, schema]
+ );
+
+ const disallowChange =
+ readonly || schemaStatus === "dropped" || status === "dropped";
+
+ const handleUpdateDefinition = useCallback(
+ (code: string) => {
+ procedure.definition = code;
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, procedure }, "updated");
+ }
+ },
+ [procedure, status, editStatus, db, schema]
+ );
+
+ return (
+ <div className="flex size-full flex-col">
+ <MonacoEditor
+ content={procedure.definition}
+ language={language}
+ readOnly={disallowChange}
+ className="flex-1"
+ options={{
+ minimap: { enabled: false },
+ lineNumbers: "on",
+ scrollBeyondLastLine: false,
+ }}
+ onChange={handleUpdateDefinition}
+ />
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/DataTypeCell.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/DataTypeCell.tsx
new file mode 100644
index 0000000000..9505c19f3b
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/DataTypeCell.tsx
@@ -0,0 +1,37 @@
+import { useMemo } from "react";
+import { Combobox } from "@/react/components/ui/combobox";
+import type { Engine } from "@/types/proto-es/v1/common_pb";
+import type { ColumnMetadata } from "@/types/proto-es/v1/database_service_pb";
+import { getDataTypeSuggestionList } from "@/utils";
+
+interface Props {
+ column: ColumnMetadata;
+ engine: Engine;
+ readonly: boolean;
+ onUpdateValue: (value: string) => void;
+}
+
+export function DataTypeCell({
+ column,
+ engine,
+ readonly: isReadonly,
+ onUpdateValue,
+}: Props) {
+ const options = useMemo(() => {
+ return getDataTypeSuggestionList(engine).map((dataType) => ({
+ label: dataType,
+ value: dataType,
+ }));
+ }, [engine]);
+
+ return (
+ <Combobox
+ value={column.type || ""}
+ onChange={(val) => onUpdateValue(val as string)}
+ options={options}
+ disabled={isReadonly}
+ placeholder="column type"
+ className="h-7"
+ />
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/DefaultValueCell.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/DefaultValueCell.tsx
new file mode 100644
index 0000000000..f3e0e10070
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/DefaultValueCell.tsx
@@ -0,0 +1,39 @@
+import { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+import { Input } from "@/react/components/ui/input";
+import type { ColumnMetadata } from "@/types/proto-es/v1/database_service_pb";
+
+interface DefaultValue {
+ hasDefault: boolean;
+ default: string;
+}
+
+interface Props {
+ column: ColumnMetadata;
+ disabled: boolean;
+ onUpdate: (value: DefaultValue) => void;
+}
+
+export function DefaultValueCell({ column, disabled, onUpdate }: Props) {
+ const { t } = useTranslation();
+
+ const handleChange = useCallback(
+ (value: string) => {
+ onUpdate({
+ hasDefault: !!value.trim(),
+ default: value.trim(),
+ });
+ },
+ [onUpdate]
+ );
+
+ return (
+ <Input
+ value={column.default ?? ""}
+ disabled={disabled}
+ placeholder={t("schema-editor.default.placeholder")}
+ className="h-7 border-none bg-transparent shadow-none focus-visible:ring-1"
+ onChange={(e) => handleChange(e.target.value)}
+ />
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/TableColumnEditor.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/TableColumnEditor.tsx
new file mode 100644
index 0000000000..5a11729a03
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/TableColumnEditor.tsx
@@ -0,0 +1,332 @@
+import { RotateCcw, Trash2 } from "lucide-react";
+import { useCallback, useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import {
+ removeColumnPrimaryKey,
+ upsertColumnPrimaryKey,
+} from "@/components/SchemaEditorLite/edit";
+import { Button } from "@/react/components/ui/button";
+import { Input } from "@/react/components/ui/input";
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from "@/react/components/ui/table";
+import { cn } from "@/react/lib/utils";
+import type { Engine } from "@/types/proto-es/v1/common_pb";
+import type {
+ ColumnMetadata,
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+ TableMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../../context";
+import { markUUID } from "../common";
+import { DataTypeCell } from "./DataTypeCell";
+import { DefaultValueCell } from "./DefaultValueCell";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ engine: Engine;
+ readonly: boolean;
+ disableChangeTable: boolean;
+ allowChangePrimaryKeys: boolean;
+ searchPattern?: string;
+ onMarkTableStatus: (status: "updated") => void;
+}
+
+export function TableColumnEditor({
+ db,
+ database: _database,
+ schema,
+ table,
+ engine,
+ readonly: isReadonly,
+ disableChangeTable,
+ allowChangePrimaryKeys,
+ searchPattern,
+ onMarkTableStatus,
+}: Props) {
+ const { t } = useTranslation();
+ const { editStatus } = useSchemaEditorContext();
+
+ const primaryKey = useMemo(() => {
+ return table.indexes.find((idx) => idx.primary);
+ }, [table.indexes]);
+
+ const isColumnPrimaryKey = useCallback(
+ (column: ColumnMetadata) => {
+ return primaryKey?.expressions.includes(column.name) ?? false;
+ },
+ [primaryKey]
+ );
+
+ const columns = useMemo(() => {
+ if (!searchPattern) return table.columns;
+ const pattern = searchPattern.toLowerCase();
+ return table.columns.filter((c) => c.name.toLowerCase().includes(pattern));
+ }, [table.columns, searchPattern]);
+
+ const getColumnKey = useCallback((column: ColumnMetadata) => {
+ return markUUID(column);
+ }, []);
+
+ const getStatus = useCallback(
+ (column: ColumnMetadata) => {
+ return editStatus.getColumnStatus(db, { schema, table, column });
+ },
+ [editStatus, db, schema, table]
+ );
+
+ const handleColumnNameChange = useCallback(
+ (column: ColumnMetadata, newName: string) => {
+ const oldName = column.name;
+ column.name = newName;
+ // Sync PK name if column is in PK
+ if (primaryKey && primaryKey.expressions.includes(oldName)) {
+ const idx = primaryKey.expressions.indexOf(oldName);
+ if (idx >= 0) {
+ primaryKey.expressions[idx] = newName;
+ }
+ }
+ const status = getStatus(column);
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, column }, "updated");
+ }
+ onMarkTableStatus("updated");
+ },
+ [primaryKey, getStatus, editStatus, db, schema, table, onMarkTableStatus]
+ );
+
+ const handleColumnTypeChange = useCallback(
+ (column: ColumnMetadata, newType: string) => {
+ column.type = newType;
+ const status = getStatus(column);
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, column }, "updated");
+ }
+ onMarkTableStatus("updated");
+ },
+ [getStatus, editStatus, db, schema, table, onMarkTableStatus]
+ );
+
+ const handleDefaultChange = useCallback(
+ (
+ column: ColumnMetadata,
+ value: { hasDefault: boolean; default: string }
+ ) => {
+ column.hasDefault = value.hasDefault;
+ column.default = value.default;
+ const status = getStatus(column);
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, column }, "updated");
+ }
+ onMarkTableStatus("updated");
+ },
+ [getStatus, editStatus, db, schema, table, onMarkTableStatus]
+ );
+
+ const handleNullableChange = useCallback(
+ (column: ColumnMetadata, nullable: boolean) => {
+ column.nullable = nullable;
+ const status = getStatus(column);
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, column }, "updated");
+ }
+ onMarkTableStatus("updated");
+ },
+ [getStatus, editStatus, db, schema, table, onMarkTableStatus]
+ );
+
+ const handlePrimaryKeyChange = useCallback(
+ (column: ColumnMetadata, isPK: boolean) => {
+ if (isPK) {
+ column.nullable = false;
+ upsertColumnPrimaryKey(engine, table, column.name);
+ } else {
+ removeColumnPrimaryKey(table, column.name);
+ }
+ const status = getStatus(column);
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, column }, "updated");
+ }
+ onMarkTableStatus("updated");
+ },
+ [engine, table, getStatus, editStatus, db, schema, onMarkTableStatus]
+ );
+
+ const handleCommentChange = useCallback(
+ (column: ColumnMetadata, comment: string) => {
+ column.comment = comment; // ColumnMetadata.comment
+ const status = getStatus(column);
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, table, column }, "updated");
+ }
+ onMarkTableStatus("updated");
+ },
+ [getStatus, editStatus, db, schema, table, onMarkTableStatus]
+ );
+
+ const handleDropColumn = useCallback(
+ (column: ColumnMetadata) => {
+ const status = getStatus(column);
+ if (status === "created") {
+ const idx = table.columns.indexOf(column);
+ if (idx >= 0) table.columns.splice(idx, 1);
+ editStatus.removeEditStatus(db, { schema, table, column }, true);
+ } else {
+ editStatus.markEditStatus(db, { schema, table, column }, "dropped");
+ }
+ onMarkTableStatus("updated");
+ },
+ [getStatus, table, editStatus, db, schema, onMarkTableStatus]
+ );
+
+ const handleRestoreColumn = useCallback(
+ (column: ColumnMetadata) => {
+ editStatus.removeEditStatus(db, { schema, table, column }, false);
+ },
+ [editStatus, db, schema, table]
+ );
+
+ return (
+ <div className="size-full overflow-auto">
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead className="w-[180px]">
+ {t("schema-editor.column.name")}
+ </TableHead>
+ <TableHead className="w-[160px]">
+ {t("schema-editor.column.type")}
+ </TableHead>
+ <TableHead className="w-[140px]">
+ {t("schema-editor.column.default")}
+ </TableHead>
+ <TableHead className="w-[160px]">
+ {t("schema-editor.column.comment")}
+ </TableHead>
+ <TableHead className="w-16 text-center">
+ {t("schema-editor.column.not-null")}
+ </TableHead>
+ <TableHead className="w-16 text-center">
+ {t("schema-editor.column.primary")}
+ </TableHead>
+ {!isReadonly && (
+ <TableHead className="w-16 text-right">
+ {t("schema-editor.column.operations")}
+ </TableHead>
+ )}
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {columns.map((column) => {
+ const key = getColumnKey(column);
+ const status = getStatus(column);
+ const isPK = isColumnPrimaryKey(column);
+ const disabled =
+ isReadonly || disableChangeTable || status === "dropped";
+
+ return (
+ <TableRow
+ key={key}
+ className={cn(
+ status === "created" && "text-success",
+ status === "updated" && "text-warning",
+ status === "dropped" && "text-error line-through"
+ )}
+ >
+ <TableCell>
+ <Input
+ value={column.name}
+ disabled={disabled}
+ className="h-7 border-none bg-transparent shadow-none focus-visible:ring-1"
+ onChange={(e) =>
+ handleColumnNameChange(column, e.target.value)
+ }
+ />
+ </TableCell>
+ <TableCell>
+ <DataTypeCell
+ column={column}
+ engine={engine}
+ readonly={disabled}
+ onUpdateValue={(val) => handleColumnTypeChange(column, val)}
+ />
+ </TableCell>
+ <TableCell>
+ <DefaultValueCell
+ column={column}
+ disabled={disabled}
+ onUpdate={(val) => handleDefaultChange(column, val)}
+ />
+ </TableCell>
+ <TableCell>
+ <Input
+ value={column.comment}
+ disabled={disabled}
+ className="h-7 border-none bg-transparent shadow-none focus-visible:ring-1"
+ onChange={(e) =>
+ handleCommentChange(column, e.target.value)
+ }
+ />
+ </TableCell>
+ <TableCell className="text-center">
+ <input
+ type="checkbox"
+ checked={!column.nullable}
+ disabled={disabled || isPK}
+ onChange={(e) =>
+ handleNullableChange(column, !e.target.checked)
+ }
+ />
+ </TableCell>
+ <TableCell className="text-center">
+ <input
+ type="checkbox"
+ checked={isPK}
+ disabled={disabled || !allowChangePrimaryKeys}
+ onChange={(e) =>
+ handlePrimaryKeyChange(column, e.target.checked)
+ }
+ />
+ </TableCell>
+ {!isReadonly && (
+ <TableCell className="text-right">
+ {status === "dropped" ? (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 p-0"
+ onClick={() => handleRestoreColumn(column)}
+ >
+ <RotateCcw className="size-3.5" />
+ </Button>
+ ) : (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 p-0 text-error hover:text-error"
+ disabled={disableChangeTable}
+ onClick={() => handleDropColumn(column)}
+ >
+ <Trash2 className="size-3.5" />
+ </Button>
+ )}
+ </TableCell>
+ )}
+ </TableRow>
+ );
+ })}
+ </TableBody>
+ </Table>
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/index.ts b/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/index.ts
new file mode 100644
index 0000000000..665d619e7d
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/TableColumnEditor/index.ts
@@ -0,0 +1 @@
+export { TableColumnEditor } from "./TableColumnEditor";
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/TableEditor.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/TableEditor.tsx
new file mode 100644
index 0000000000..eccb91e225
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/TableEditor.tsx
@@ -0,0 +1,175 @@
+import { create } from "@bufbuild/protobuf";
+import { Plus } from "lucide-react";
+import { useCallback, useMemo, useState } from "react";
+import { useTranslation } from "react-i18next";
+import {
+ engineSupportsEditIndexes,
+ engineSupportsEditTablePartitions,
+} from "@/components/SchemaEditorLite/spec";
+import { Button } from "@/react/components/ui/button";
+import type {
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+ TableMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { ColumnMetadataSchema } from "@/types/proto-es/v1/database_service_pb";
+import { getDatabaseEngine } from "@/utils";
+import { useSchemaEditorContext } from "../context";
+import { markUUID } from "./common";
+import { IndexesEditor } from "./IndexesEditor";
+import { PartitionsEditor } from "./PartitionsEditor";
+import { PreviewPane } from "./PreviewPane";
+import { TableColumnEditor } from "./TableColumnEditor";
+
+type EditorMode = "COLUMNS" | "INDEXES" | "PARTITIONS";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ searchPattern?: string;
+}
+
+export function TableEditor({
+ db,
+ database,
+ schema,
+ table,
+ searchPattern,
+}: Props) {
+ const { t } = useTranslation();
+ const { readonly, editStatus, scrollStatus, rebuildTree, options } =
+ useSchemaEditorContext();
+
+ const [mode, setMode] = useState<EditorMode>("COLUMNS");
+ const engine = getDatabaseEngine(db);
+
+ const disableChangeTable = useMemo(() => {
+ const schemaStatus = editStatus.getSchemaStatus(db, { schema });
+ const tableStatus = editStatus.getTableStatus(db, { schema, table });
+ return schemaStatus === "dropped" || tableStatus === "dropped";
+ }, [editStatus, db, schema, table]);
+
+ const tableStatus = useMemo(
+ () => editStatus.getTableStatus(db, { schema, table }),
+ [editStatus, db, schema, table]
+ );
+
+ const allowChangePrimaryKeys = tableStatus === "created";
+
+ const showIndexes =
+ engineSupportsEditIndexes(engine) || (options?.forceShowIndexes ?? false);
+
+ const showPartitions =
+ engineSupportsEditTablePartitions(engine) ||
+ (options?.forceShowPartitions ?? false);
+
+ const handleAddColumn = useCallback(() => {
+ const column = create(ColumnMetadataSchema, {
+ name: "",
+ type: "",
+ nullable: true,
+ hasDefault: false,
+ default: "",
+ comment: "",
+ });
+ markUUID(column);
+ table.columns.push(column);
+ editStatus.markEditStatus(db, { schema, table, column }, "created");
+ rebuildTree(false);
+ scrollStatus.queuePendingScrollToColumn({
+ db,
+ metadata: { database, schema, table, column },
+ });
+ }, [db, database, schema, table, editStatus, rebuildTree, scrollStatus]);
+
+ const markTableStatus = useCallback(
+ (status: "updated") => {
+ if (tableStatus === "created" || tableStatus === "dropped") return;
+ editStatus.markEditStatus(db, { schema, table }, status);
+ },
+ [tableStatus, editStatus, db, schema, table]
+ );
+
+ return (
+ <div className="flex size-full flex-col gap-y-2 overflow-y-hidden pt-2">
+ {/* Toolbar */}
+ <div className="flex items-center gap-x-2 px-4">
+ <div className="flex items-center gap-x-1">
+ <Button
+ variant={mode === "COLUMNS" ? "default" : "outline"}
+ size="sm"
+ onClick={() => setMode("COLUMNS")}
+ >
+ {t("schema-editor.columns")}
+ </Button>
+ {showIndexes && (
+ <Button
+ variant={mode === "INDEXES" ? "default" : "outline"}
+ size="sm"
+ onClick={() => setMode("INDEXES")}
+ >
+ {t("schema-editor.indexes")}
+ </Button>
+ )}
+ {showPartitions && (
+ <Button
+ variant={mode === "PARTITIONS" ? "default" : "outline"}
+ size="sm"
+ onClick={() => setMode("PARTITIONS")}
+ >
+ {t("schema-editor.partitions")}
+ </Button>
+ )}
+ </div>
+ {!readonly && !disableChangeTable && mode === "COLUMNS" && (
+ <Button variant="outline" size="sm" onClick={handleAddColumn}>
+ <Plus className="mr-1 size-4" />
+ {t("schema-editor.actions.add-column")}
+ </Button>
+ )}
+ </div>
+
+ {/* Content */}
+ <div className="flex-1 overflow-y-hidden px-4">
+ {mode === "COLUMNS" && (
+ <TableColumnEditor
+ db={db}
+ database={database}
+ schema={schema}
+ table={table}
+ engine={engine}
+ readonly={readonly}
+ disableChangeTable={disableChangeTable}
+ allowChangePrimaryKeys={allowChangePrimaryKeys}
+ searchPattern={searchPattern}
+ onMarkTableStatus={markTableStatus}
+ />
+ )}
+ {mode === "INDEXES" && (
+ <IndexesEditor
+ db={db}
+ database={database}
+ schema={schema}
+ table={table}
+ readonly={readonly}
+ />
+ )}
+ {mode === "PARTITIONS" && (
+ <PartitionsEditor
+ db={db}
+ database={database}
+ schema={schema}
+ table={table}
+ readonly={readonly}
+ />
+ )}
+ </div>
+
+ {/* Preview */}
+ <PreviewPane db={db} database={database} schema={schema} table={table} />
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/TableList/TableList.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/TableList/TableList.tsx
new file mode 100644
index 0000000000..c2385487da
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/TableList/TableList.tsx
@@ -0,0 +1,154 @@
+import { RotateCcw, Trash2 } from "lucide-react";
+import { useCallback, useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import { Button } from "@/react/components/ui/button";
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from "@/react/components/ui/table";
+import { cn } from "@/react/lib/utils";
+import type {
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+ TableMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { useSchemaEditorContext } from "../../context";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ tables: TableMetadata[];
+ searchPattern?: string;
+ onEditTable: (table: { name: string }) => void;
+}
+
+export function TableList({
+ db,
+ schema,
+ tables,
+ searchPattern,
+ onEditTable,
+}: Props) {
+ const { t } = useTranslation();
+ const { readonly, editStatus } = useSchemaEditorContext();
+
+ const filteredTables = useMemo(() => {
+ if (!searchPattern) return tables;
+ const pattern = searchPattern.toLowerCase();
+ return tables.filter((t) => t.name.toLowerCase().includes(pattern));
+ }, [tables, searchPattern]);
+
+ const getStatus = useCallback(
+ (table: TableMetadata) => {
+ return editStatus.getTableStatus(db, { schema, table });
+ },
+ [editStatus, db, schema]
+ );
+
+ const handleDrop = useCallback(
+ (table: TableMetadata) => {
+ const status = getStatus(table);
+ if (status === "created") {
+ // Remove from array entirely
+ const idx = schema.tables.indexOf(table);
+ if (idx >= 0) schema.tables.splice(idx, 1);
+ editStatus.removeEditStatus(db, { schema, table }, true);
+ } else {
+ editStatus.markEditStatus(db, { schema, table }, "dropped");
+ }
+ },
+ [getStatus, schema, editStatus, db]
+ );
+
+ const handleRestore = useCallback(
+ (table: TableMetadata) => {
+ editStatus.removeEditStatus(db, { schema, table }, false);
+ },
+ [editStatus, db, schema]
+ );
+
+ if (filteredTables.length === 0) {
+ return (
+ <div className="flex size-full items-center justify-center py-8 text-sm text-control-light">
+ {searchPattern
+ ? t("schema-editor.table.no-match")
+ : t("schema-editor.table.no-tables")}
+ </div>
+ );
+ }
+
+ return (
+ <Table>
+ <TableHeader>
+ <TableRow>
+ <TableHead className="w-[40%]">
+ {t("schema-editor.column.name")}
+ </TableHead>
+ <TableHead>{t("schema-editor.column.comment")}</TableHead>
+ {!readonly && (
+ <TableHead className="w-20 text-right">
+ {t("schema-editor.column.operations")}
+ </TableHead>
+ )}
+ </TableRow>
+ </TableHeader>
+ <TableBody>
+ {filteredTables.map((table) => {
+ const status = getStatus(table);
+ return (
+ <TableRow
+ key={table.name}
+ className={cn(
+ "cursor-pointer",
+ status === "created" && "text-success",
+ status === "updated" && "text-warning",
+ status === "dropped" && "text-error line-through"
+ )}
+ onClick={() => onEditTable(table)}
+ >
+ <TableCell className="font-medium">{table.name}</TableCell>
+ <TableCell className="text-control-light">
+ {table.comment || "—"}
+ </TableCell>
+ {!readonly && (
+ <TableCell className="text-right">
+ {status === "dropped" ? (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 p-0"
+ onClick={(e) => {
+ e.stopPropagation();
+ handleRestore(table);
+ }}
+ >
+ <RotateCcw className="size-3.5" />
+ </Button>
+ ) : (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 p-0 text-error hover:text-error"
+ onClick={(e) => {
+ e.stopPropagation();
+ handleDrop(table);
+ }}
+ >
+ <Trash2 className="size-3.5" />
+ </Button>
+ )}
+ </TableCell>
+ )}
+ </TableRow>
+ );
+ })}
+ </TableBody>
+ </Table>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/TableList/index.ts b/frontend/src/react/components/SchemaEditorLite/Panels/TableList/index.ts
new file mode 100644
index 0000000000..42ed5c4db4
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/TableList/index.ts
@@ -0,0 +1 @@
+export { TableList } from "./TableList";
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/ViewEditor.tsx b/frontend/src/react/components/SchemaEditorLite/Panels/ViewEditor.tsx
new file mode 100644
index 0000000000..ffa0b2b9c7
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/ViewEditor.tsx
@@ -0,0 +1,64 @@
+import { useCallback, useMemo } from "react";
+import { MonacoEditor } from "@/react/components/monaco/MonacoEditor";
+import type {
+ Database,
+ DatabaseMetadata,
+ SchemaMetadata,
+ ViewMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import { languageOfEngineV1 } from "@/types/sqlEditor/editor";
+import { getDatabaseEngine } from "@/utils";
+import { useSchemaEditorContext } from "../context";
+
+interface Props {
+ db: Database;
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ view: ViewMetadata;
+}
+
+export function ViewEditor({ db, schema, view }: Props) {
+ const { readonly, editStatus } = useSchemaEditorContext();
+ const engine = getDatabaseEngine(db);
+ const language = languageOfEngineV1(engine);
+
+ const status = useMemo(
+ () => editStatus.getViewStatus(db, { schema, view }),
+ [editStatus, db, schema, view]
+ );
+
+ const schemaStatus = useMemo(
+ () => editStatus.getSchemaStatus(db, { schema }),
+ [editStatus, db, schema]
+ );
+
+ const disallowChange =
+ readonly || schemaStatus === "dropped" || status === "dropped";
+
+ const handleUpdateDefinition = useCallback(
+ (code: string) => {
+ view.definition = code;
+ if (status === "normal") {
+ editStatus.markEditStatus(db, { schema, view }, "updated");
+ }
+ },
+ [view, status, editStatus, db, schema]
+ );
+
+ return (
+ <div className="flex size-full flex-col">
+ <MonacoEditor
+ content={view.definition}
+ language={language}
+ readOnly={disallowChange}
+ className="flex-1"
+ options={{
+ minimap: { enabled: false },
+ lineNumbers: "on",
+ scrollBeyondLastLine: false,
+ }}
+ onChange={handleUpdateDefinition}
+ />
+ </div>
+ );
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/Panels/common.ts b/frontend/src/react/components/SchemaEditorLite/Panels/common.ts
new file mode 100644
index 0000000000..c8e3ceb074
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/Panels/common.ts
@@ -0,0 +1,36 @@
+import { v1 as uuidv1 } from "uuid";
+import type { EditStatus } from "../types";
+
+interface ObjectWithHiddenProps {
+ __uuid?: string;
+ __status_before_drop?: EditStatus;
+}
+
+export const markUUID = (obj: object): string => {
+ const target = obj as ObjectWithHiddenProps;
+ if (!target.__uuid) {
+ Object.defineProperty(obj, "__uuid", {
+ enumerable: false,
+ writable: false,
+ configurable: false,
+ value: uuidv1(),
+ });
+ }
+ return target.__uuid as string;
+};
+
+export const markEditStatusBeforeDrop = (obj: object, status: EditStatus) => {
+ const target = obj as ObjectWithHiddenProps;
+ Object.defineProperty(target, "__status_before_drop", {
+ enumerable: false,
+ writable: true,
+ configurable: true,
+ value: status,
+ });
+};
+
+export const getEditStatusBeforeDrop = (
+ obj: object
+): EditStatus | undefined => {
+ return (obj as ObjectWithHiddenProps).__status_before_drop;
+};
diff --git a/frontend/src/react/components/SchemaEditorLite/SchemaEditorLite.tsx b/frontend/src/react/components/SchemaEditorLite/SchemaEditorLite.tsx
new file mode 100644
index 0000000000..1e38d0a313
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/SchemaEditorLite.tsx
@@ -0,0 +1,219 @@
+import { cloneDeep } from "lodash-es";
+import { Loader2 } from "lucide-react";
+import {
+ forwardRef,
+ useCallback,
+ useImperativeHandle,
+ useMemo,
+ useRef,
+ useState,
+} from "react";
+import {
+ Panel,
+ Group as PanelGroup,
+ Separator as PanelResizeHandle,
+} from "react-resizable-panels";
+import type { DatabaseMetadata } from "@/types/proto-es/v1/database_service_pb";
+import { AsideTree } from "./Aside/AsideTree";
+import { SchemaEditorProvider } from "./context";
+import { EditorPanel } from "./EditorPanel";
+import type {
+ RebuildMetadataEditReset,
+ SchemaEditorContextValue,
+ SchemaEditorHandle,
+ SchemaEditorProps,
+} from "./types";
+import { useAlgorithm } from "./useAlgorithm";
+import { useEditStatus } from "./useEditStatus";
+import { useScrollStatus } from "./useScrollStatus";
+import { useSelection } from "./useSelection";
+import { useTabs } from "./useTabs";
+
+export const SchemaEditorLite = forwardRef<
+ SchemaEditorHandle,
+ SchemaEditorProps
+>(function SchemaEditorLite(props, ref) {
+ const {
+ project,
+ readonly = false,
+ selectedRolloutObjects,
+ targets: targetsProp,
+ loading = false,
+ hidePreview = false,
+ options,
+ onSelectedRolloutObjectsChange,
+ } = props;
+
+ const targets = useMemo(() => targetsProp ?? [], [targetsProp]);
+ const ready = targets.length > 0;
+ const combinedLoading = loading || !ready;
+
+ // Tree rebuild trigger — version bumps cause AsideTree to re-derive tree data
+ const [treeBuildVersion, setTreeBuildVersion] = useState(0);
+ const rebuildTreeCallbackRef = useRef<
+ ((openFirstChild: boolean) => void) | null
+ >(null);
+
+ const rebuildTree = useCallback((openFirstChild: boolean) => {
+ setTreeBuildVersion((v) => v + 1);
+ rebuildTreeCallbackRef.current?.(openFirstChild);
+ }, []);
+
+ // Preview refresh trigger — version bumps cause PreviewPane to re-generate DDL
+ const [, setPreviewVersion] = useState(0);
+ const refreshPreview = useCallback(() => {
+ setPreviewVersion((v) => v + 1);
+ }, []);
+
+ // Sub-hooks
+ const tabs = useTabs();
+ const editStatus = useEditStatus();
+ const selection = useSelection(
+ selectedRolloutObjects,
+ onSelectedRolloutObjectsChange
+ );
+ const scrollStatus = useScrollStatus();
+
+ // Algorithm layer
+ const algorithmCallbacks = useMemo(
+ () => ({
+ clearTabs: tabs.clearTabs,
+ rebuildTree,
+ }),
+ [tabs.clearTabs, rebuildTree]
+ );
+ const { rebuildMetadataEdit, applyMetadataEdit } = useAlgorithm(
+ editStatus,
+ algorithmCallbacks
+ );
+
+ // Merge metadata callback (replaces Emittery "merge-metadata" event)
+ const mergeMetadata = useCallback(
+ (metadatas: DatabaseMetadata[]) => {
+ for (const metadata of metadatas) {
+ const target = targets.find((t) => t.metadata.name === metadata.name);
+ if (!target) continue;
+
+ mergeTableMetadataToTarget({
+ metadata,
+ mergeTo: target.metadata,
+ });
+ mergeTableMetadataToTarget({
+ metadata,
+ mergeTo: target.baselineMetadata,
+ });
+ }
+ },
+ [targets]
+ );
+
+ // Rebuild edit status callback
+ const rebuildEditStatusCallback = useCallback(
+ (resets: RebuildMetadataEditReset[]) => {
+ if (ready) {
+ targets.forEach((target) => {
+ rebuildMetadataEdit(target, resets);
+ });
+ }
+ },
+ [ready, targets, rebuildMetadataEdit]
+ );
+
+ // Compose context value
+ const contextValue = useMemo<SchemaEditorContextValue>(
+ () => ({
+ readonly,
+ project,
+ targets,
+ hidePreview,
+ options,
+ treeBuildVersion,
+ tabs,
+ editStatus,
+ selection,
+ scrollStatus,
+ rebuildTree,
+ rebuildEditStatus: rebuildEditStatusCallback,
+ refreshPreview,
+ mergeMetadata,
+ applyMetadataEdit,
+ rebuildMetadataEdit,
+ }),
+ [
+ readonly,
+ project,
+ targets,
+ hidePreview,
+ options,
+ treeBuildVersion,
+ tabs,
+ editStatus,
+ selection,
+ scrollStatus,
+ rebuildTree,
+ rebuildEditStatusCallback,
+ refreshPreview,
+ mergeMetadata,
+ applyMetadataEdit,
+ rebuildMetadataEdit,
+ ]
+ );
+
+ // Imperative handle
+ useImperativeHandle(
+ ref,
+ () => ({
+ applyMetadataEdit,
+ refreshPreview,
+ isDirty: editStatus.isDirty,
+ }),
+ [applyMetadataEdit, refreshPreview, editStatus.isDirty]
+ );
+
+ return (
+ <SchemaEditorProvider value={contextValue}>
+ <div className="bb-schema-editor relative flex size-full flex-col overflow-hidden rounded-sm border">
+ {combinedLoading && (
+ <div className="absolute inset-0 z-10 flex items-center justify-center bg-white/60">
+ <Loader2 className="size-8 animate-spin text-accent" />
+ </div>
+ )}
+ {ready && (
+ <PanelGroup id="schema-editor" orientation="horizontal">
+ <Panel defaultSize={25} minSize={15} maxSize={40}>
+ <div className="size-full overflow-hidden">
+ <AsideTree />
+ </div>
+ </Panel>
+ <PanelResizeHandle className="w-[3px] bg-control-border transition-colors hover:bg-accent data-[resize-handle-active]:bg-accent" />
+ <Panel defaultSize={75}>
+ <div className="size-full overflow-hidden">
+ <EditorPanel />
+ </div>
+ </Panel>
+ </PanelGroup>
+ )}
+ </div>
+ </SchemaEditorProvider>
+ );
+});
+
+function mergeTableMetadataToTarget({
+ metadata,
+ mergeTo,
+}: {
+ metadata: DatabaseMetadata;
+ mergeTo: DatabaseMetadata;
+}) {
+ for (const schema of metadata.schemas) {
+ if (schema.tables.length === 0) continue;
+ const targetSchema = mergeTo.schemas.find((s) => s.name === schema.name);
+ if (!targetSchema) continue;
+
+ for (const table of schema.tables) {
+ if (!targetSchema.tables.find((t) => t.name === table.name)) {
+ targetSchema.tables.push(cloneDeep(table));
+ }
+ }
+ }
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/TabsContainer.tsx b/frontend/src/react/components/SchemaEditorLite/TabsContainer.tsx
new file mode 100644
index 0000000000..dea0a4c4b1
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/TabsContainer.tsx
@@ -0,0 +1,115 @@
+import {
+ Database as DatabaseIcon,
+ FileCode,
+ FunctionSquare,
+ Table2,
+ View,
+ X,
+} from "lucide-react";
+import { useEffect, useRef } from "react";
+import { EllipsisText } from "@/react/components/ui/ellipsis-text";
+import { cn } from "@/react/lib/utils";
+import { useSchemaEditorContext } from "./context";
+import type { EditStatus, TabContext } from "./types";
+
+export function TabsContainer() {
+ const { tabs, editStatus } = useSchemaEditorContext();
+ const { tabList, currentTab, setCurrentTab, closeTab } = tabs;
+ const activeTabRef = useRef<HTMLDivElement>(null);
+
+ // Auto-scroll active tab into view
+ useEffect(() => {
+ if (activeTabRef.current) {
+ activeTabRef.current.scrollIntoView({
+ behavior: "smooth",
+ block: "nearest",
+ inline: "nearest",
+ });
+ }
+ }, [currentTab?.id]);
+
+ if (tabList.length === 0) return null;
+
+ return (
+ <div className="flex items-center justify-between border-b border-control-border">
+ <div className="flex flex-1 items-center gap-x-1 overflow-x-auto px-1 py-1 scrollbar-hide">
+ {tabList.map((tab) => {
+ const isActive = tab.id === currentTab?.id;
+ const status = getTabStatus(tab, editStatus);
+ return (
+ <div
+ key={tab.id}
+ ref={isActive ? activeTabRef : undefined}
+ className={cn(
+ "group flex w-40 shrink-0 cursor-pointer items-center gap-x-1 rounded-xs px-2 py-1 text-xs transition-colors",
+ isActive
+ ? "bg-control-bg-hover text-control"
+ : "text-control-light hover:bg-control-bg-hover",
+ status === "dropped" && "text-error line-through",
+ status === "created" && "text-success",
+ status === "updated" && "text-warning"
+ )}
+ onClick={() => setCurrentTab(tab.id)}
+ >
+ <TabIcon type={tab.type} />
+ <EllipsisText text={getTabName(tab)} className="flex-1" />
+ <button
+ className="ml-auto hidden size-4 shrink-0 items-center justify-center rounded-xs hover:bg-control-border group-hover:flex"
+ onClick={(e) => {
+ e.stopPropagation();
+ closeTab(tab.id);
+ }}
+ >
+ <X className="size-3" />
+ </button>
+ </div>
+ );
+ })}
+ </div>
+ </div>
+ );
+}
+
+function TabIcon({ type }: { type: TabContext["type"] }) {
+ const cls = "size-3.5 shrink-0";
+ switch (type) {
+ case "database":
+ return <DatabaseIcon className={cls} />;
+ case "table":
+ return <Table2 className={cls} />;
+ case "view":
+ return <View className={cls} />;
+ case "procedure":
+ return <FileCode className={cls} />;
+ case "function":
+ return <FunctionSquare className={cls} />;
+ }
+}
+
+function getTabName(tab: TabContext): string {
+ const meta = tab.metadata as Record<string, { name: string }>;
+ if (tab.type === "database") {
+ return meta.database.name;
+ }
+ const schema = meta.schema?.name;
+ const objectName =
+ meta.table?.name ??
+ meta.view?.name ??
+ meta.procedure?.name ??
+ meta.function?.name ??
+ "";
+ if (schema) {
+ return `${schema}.${objectName}`;
+ }
+ return objectName;
+}
+
+function getTabStatus(
+ tab: TabContext,
+ editStatus: ReturnType<typeof useSchemaEditorContext>["editStatus"]
+): EditStatus {
+ if (tab.type === "table") {
+ return editStatus.getTableStatus(tab.database, tab.metadata);
+ }
+ return "normal";
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/context.tsx b/frontend/src/react/components/SchemaEditorLite/context.tsx
new file mode 100644
index 0000000000..d6557fbdfa
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/context.tsx
@@ -0,0 +1,30 @@
+import { createContext, useContext } from "react";
+import type { SchemaEditorContextValue } from "./types";
+
+const SchemaEditorContext = createContext<SchemaEditorContextValue | null>(
+ null
+);
+
+export function SchemaEditorProvider({
+ value,
+ children,
+}: {
+ value: SchemaEditorContextValue;
+ children: React.ReactNode;
+}) {
+ return (
+ <SchemaEditorContext.Provider value={value}>
+ {children}
+ </SchemaEditorContext.Provider>
+ );
+}
+
+export function useSchemaEditorContext(): SchemaEditorContextValue {
+ const context = useContext(SchemaEditorContext);
+ if (!context) {
+ throw new Error(
+ "useSchemaEditorContext must be used within a SchemaEditorProvider"
+ );
+ }
+ return context;
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/index.ts b/frontend/src/react/components/SchemaEditorLite/index.ts
new file mode 100644
index 0000000000..a6f396efd8
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/index.ts
@@ -0,0 +1,7 @@
+export { SchemaEditorLite } from "./SchemaEditorLite";
+export { SchemaEditorProvider, useSchemaEditorContext } from "./context";
+export type {
+ SchemaEditorContextValue,
+ SchemaEditorHandle,
+ SchemaEditorProps,
+} from "./types";
diff --git a/frontend/src/react/components/SchemaEditorLite/types.ts b/frontend/src/react/components/SchemaEditorLite/types.ts
new file mode 100644
index 0000000000..565feca958
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/types.ts
@@ -0,0 +1,381 @@
+export type {
+ CommonTabContext,
+ CoreTabContext,
+ EditStatus,
+ EditTarget,
+ RolloutObject,
+ TabContext,
+ TabType,
+} from "@/components/SchemaEditorLite/types";
+
+import type { CoreTabContext } from "@/components/SchemaEditorLite/types";
+
+export type { RebuildMetadataEditReset } from "@/components/SchemaEditorLite/algorithm/rebuild";
+
+import type { RebuildMetadataEditReset } from "@/components/SchemaEditorLite/algorithm/rebuild";
+import type {
+ EditStatus,
+ EditTarget,
+ RolloutObject,
+ TabContext,
+} from "@/components/SchemaEditorLite/types";
+import type {
+ ColumnMetadata,
+ Database,
+ DatabaseMetadata,
+ FunctionMetadata,
+ ProcedureMetadata,
+ SchemaMetadata,
+ TableMetadata,
+ TablePartitionMetadata,
+ ViewMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import type { Project } from "@/types/proto-es/v1/project_service_pb";
+
+export type SchemaEditorOptions = {
+ forceShowIndexes: boolean;
+ forceShowPartitions: boolean;
+};
+
+export type ResourceMetadata = {
+ schema?: SchemaMetadata;
+ table?: TableMetadata;
+ column?: ColumnMetadata;
+ partition?: TablePartitionMetadata;
+ view?: ViewMetadata;
+ procedure?: ProcedureMetadata;
+ function?: FunctionMetadata;
+};
+
+export type SchemaResourceMetadata = {
+ schema: SchemaMetadata;
+ table?: TableMetadata;
+ column?: ColumnMetadata;
+ partition?: TablePartitionMetadata;
+ procedure?: ProcedureMetadata;
+ function?: FunctionMetadata;
+ view?: ViewMetadata;
+};
+
+// Scroll status rich metadata types
+export type RichSchemaMetadata = {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+};
+
+export type RichTableMetadata = RichSchemaMetadata & {
+ table: TableMetadata;
+};
+
+export type RichColumnMetadata = RichTableMetadata & {
+ column: ColumnMetadata;
+};
+
+export type RichMetadataWithDB<T> = {
+ db: Database;
+ metadata: T;
+};
+
+// Selection state
+export type SelectionState = {
+ checked: boolean;
+ indeterminate: boolean;
+};
+
+// Tabs context
+export type TabsContext = {
+ tabList: TabContext[];
+ currentTabId: string;
+ currentTab: TabContext | undefined;
+ addTab: (coreTab: CoreTabContext, setAsCurrentTab?: boolean) => void;
+ setCurrentTab: (id: string) => void;
+ closeTab: (id: string) => void;
+ findTab: (target: CoreTabContext) => TabContext | undefined;
+ clearTabs: () => void;
+};
+
+// Edit status context
+export type EditStatusContext = {
+ isDirty: boolean;
+ markEditStatus: (
+ database: Database,
+ metadata: SchemaResourceMetadata,
+ status: EditStatus
+ ) => void;
+ markEditStatusByKey: (key: string, status: EditStatus) => void;
+ getEditStatusByKey: (key: string) => EditStatus | undefined;
+ removeEditStatus: (
+ database: Database,
+ metadata: SchemaResourceMetadata,
+ recursive: boolean
+ ) => void;
+ clearEditStatus: () => void;
+ getSchemaStatus: (
+ database: Database,
+ metadata: { schema: SchemaMetadata }
+ ) => EditStatus;
+ getTableStatus: (
+ database: Database,
+ metadata: { schema: SchemaMetadata; table: TableMetadata }
+ ) => EditStatus;
+ getColumnStatus: (
+ database: Database,
+ metadata: {
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ }
+ ) => EditStatus;
+ getPartitionStatus: (
+ database: Database,
+ metadata: {
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ partition: TablePartitionMetadata;
+ }
+ ) => EditStatus;
+ getProcedureStatus: (
+ database: Database,
+ metadata: { schema: SchemaMetadata; procedure: ProcedureMetadata }
+ ) => EditStatus;
+ getFunctionStatus: (
+ database: Database,
+ metadata: { schema: SchemaMetadata; function: FunctionMetadata }
+ ) => EditStatus;
+ getViewStatus: (
+ database: Database,
+ metadata: { schema: SchemaMetadata; view: ViewMetadata }
+ ) => EditStatus;
+ replaceTableName: (
+ database: Database,
+ metadata: { schema: SchemaMetadata; table: TableMetadata },
+ newName: string
+ ) => void;
+};
+
+// Selection context
+export type SelectionContext = {
+ selectionEnabled: boolean;
+ getTableSelectionState: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ }
+ ) => SelectionState;
+ updateTableSelection: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ },
+ on: boolean
+ ) => void;
+ getAllTablesSelectionState: (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ tables: TableMetadata[]
+ ) => SelectionState;
+ updateAllTablesSelection: (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ tables: TableMetadata[],
+ on: boolean
+ ) => void;
+ getColumnSelectionState: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ }
+ ) => SelectionState;
+ updateColumnSelection: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ },
+ on: boolean
+ ) => void;
+ getAllColumnsSelectionState: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ },
+ columns: ColumnMetadata[]
+ ) => SelectionState;
+ updateAllColumnsSelection: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ },
+ columns: ColumnMetadata[],
+ on: boolean
+ ) => void;
+ getViewSelectionState: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ view: ViewMetadata;
+ }
+ ) => SelectionState;
+ updateViewSelection: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ view: ViewMetadata;
+ },
+ on: boolean
+ ) => void;
+ getAllViewsSelectionState: (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ views: ViewMetadata[]
+ ) => SelectionState;
+ updateAllViewsSelection: (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ views: ViewMetadata[],
+ on: boolean
+ ) => void;
+ getProcedureSelectionState: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ procedure: ProcedureMetadata;
+ }
+ ) => SelectionState;
+ updateProcedureSelection: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ procedure: ProcedureMetadata;
+ },
+ on: boolean
+ ) => void;
+ getAllProceduresSelectionState: (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ procedures: ProcedureMetadata[]
+ ) => SelectionState;
+ updateAllProceduresSelection: (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ procedures: ProcedureMetadata[],
+ on: boolean
+ ) => void;
+ getFunctionSelectionState: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ function: FunctionMetadata;
+ }
+ ) => SelectionState;
+ updateFunctionSelection: (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ function: FunctionMetadata;
+ },
+ on: boolean
+ ) => void;
+ getAllFunctionsSelectionState: (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ functions: FunctionMetadata[]
+ ) => SelectionState;
+ updateAllFunctionsSelection: (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ functions: FunctionMetadata[],
+ on: boolean
+ ) => void;
+};
+
+// Scroll status context
+export type ScrollStatusContext = {
+ pendingScrollToTable: RichMetadataWithDB<RichTableMetadata> | undefined;
+ pendingScrollToColumn: RichMetadataWithDB<RichColumnMetadata> | undefined;
+ queuePendingScrollToTable: (
+ params: RichMetadataWithDB<RichTableMetadata>
+ ) => void;
+ queuePendingScrollToColumn: (
+ params: RichMetadataWithDB<RichColumnMetadata>
+ ) => void;
+ consumePendingScrollToTable: () => void;
+ consumePendingScrollToColumn: () => void;
+};
+
+// Combined context value
+export type SchemaEditorContextValue = {
+ // Props
+ readonly: boolean;
+ project: Project;
+ targets: EditTarget[];
+ hidePreview: boolean;
+ options?: SchemaEditorOptions;
+
+ // Rebuild signal — bumped by rebuildTree() so memos can invalidate
+ treeBuildVersion: number;
+
+ // Sub-contexts
+ tabs: TabsContext;
+ editStatus: EditStatusContext;
+ selection: SelectionContext;
+ scrollStatus: ScrollStatusContext;
+
+ // Callbacks (replacing Emittery events)
+ rebuildTree: (openFirstChild: boolean) => void;
+ rebuildEditStatus: (resets: RebuildMetadataEditReset[]) => void;
+ refreshPreview: () => void;
+ mergeMetadata: (metadatas: DatabaseMetadata[]) => void;
+
+ // Algorithm
+ applyMetadataEdit: (
+ database: Database,
+ metadata: DatabaseMetadata
+ ) => { metadata: DatabaseMetadata };
+ rebuildMetadataEdit: (
+ target: EditTarget,
+ resets?: RebuildMetadataEditReset[]
+ ) => void;
+};
+
+// Props for the top-level component
+export type SchemaEditorProps = {
+ project: Project;
+ readonly?: boolean;
+ selectedRolloutObjects?: RolloutObject[];
+ targets?: EditTarget[];
+ loading?: boolean;
+ hidePreview?: boolean;
+ options?: SchemaEditorOptions;
+ onSelectedRolloutObjectsChange?: (objects: RolloutObject[]) => void;
+ onIsEditingChange?: (objects: RolloutObject[]) => void;
+};
+
+// Imperative handle exposed via ref
+export type SchemaEditorHandle = {
+ applyMetadataEdit: (
+ database: Database,
+ metadata: DatabaseMetadata
+ ) => { metadata: DatabaseMetadata };
+ refreshPreview: () => void;
+ isDirty: boolean;
+};
diff --git a/frontend/src/react/components/SchemaEditorLite/useAlgorithm.ts b/frontend/src/react/components/SchemaEditorLite/useAlgorithm.ts
new file mode 100644
index 0000000000..4552afda76
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/useAlgorithm.ts
@@ -0,0 +1,115 @@
+import { cloneDeep } from "lodash-es";
+import { useCallback } from "react";
+import { DiffMerge } from "@/components/SchemaEditorLite/algorithm/diff-merge";
+import type { RebuildMetadataEditReset } from "@/components/SchemaEditorLite/algorithm/rebuild";
+import type { EditStatus } from "@/components/SchemaEditorLite/types";
+import type {
+ Database,
+ DatabaseMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import type { EditStatusContext, EditTarget } from "./types";
+
+/**
+ * Adapter interface that DiffMerge needs from context.
+ * DiffMerge only calls `markEditStatusByKey` on the context object.
+ */
+interface DiffMergeAdapter {
+ markEditStatusByKey: (key: string, status: EditStatus) => void;
+}
+
+export function useAlgorithm(
+ editStatus: EditStatusContext,
+ callbacks: {
+ clearTabs: () => void;
+ rebuildTree: (openFirstChild: boolean) => void;
+ }
+) {
+ const rebuildMetadataEdit = useCallback(
+ (target: EditTarget, resets: RebuildMetadataEditReset[] = ["tree"]) => {
+ editStatus.clearEditStatus();
+
+ const { database, metadata, baselineMetadata } = target;
+ const adapter: DiffMergeAdapter = {
+ markEditStatusByKey: editStatus.markEditStatusByKey,
+ };
+ // DiffMerge expects a context with markEditStatusByKey.
+ // We cast the adapter since DiffMerge only uses this one method at runtime.
+
+ const dm = new DiffMerge({
+ context: adapter as unknown as ConstructorParameters<
+ typeof DiffMerge
+ >[0]["context"],
+ database,
+ sourceMetadata: baselineMetadata,
+ targetMetadata: metadata,
+ });
+ dm.merge();
+ dm.timer.printAll();
+
+ // Replace Vue's nextTick with setTimeout(0) for deferred execution.
+ setTimeout(() => {
+ if (resets.includes("tabs")) {
+ callbacks.clearTabs();
+ }
+ if (resets.includes("tree")) {
+ callbacks.rebuildTree(resets.includes("tabs"));
+ }
+ }, 0);
+ },
+ [editStatus, callbacks]
+ );
+
+ const applyMetadataEdit = useCallback(
+ (database: Database, metadata: DatabaseMetadata) => {
+ const response = cloneDeep(metadata);
+ response.schemas = response.schemas.filter((schema) => {
+ const status = editStatus.getSchemaStatus(database, { schema });
+ return status !== "dropped";
+ });
+ response.schemas.forEach((schema) => {
+ schema.tables = schema.tables.filter((table) => {
+ const status = editStatus.getTableStatus(database, {
+ schema,
+ table,
+ });
+ return status !== "dropped";
+ });
+ schema.tables.forEach((table) => {
+ table.columns = table.columns.filter((column) => {
+ const status = editStatus.getColumnStatus(database, {
+ schema,
+ table,
+ column,
+ });
+ return status !== "dropped";
+ });
+ });
+ schema.views = schema.views.filter((view) => {
+ const status = editStatus.getViewStatus(database, {
+ schema,
+ view,
+ });
+ return status !== "dropped";
+ });
+ schema.procedures = schema.procedures.filter((procedure) => {
+ const status = editStatus.getProcedureStatus(database, {
+ schema,
+ procedure,
+ });
+ return status !== "dropped";
+ });
+ schema.functions = schema.functions.filter((func) => {
+ const status = editStatus.getFunctionStatus(database, {
+ schema,
+ function: func,
+ });
+ return status !== "dropped";
+ });
+ });
+ return { metadata: response };
+ },
+ [editStatus]
+ );
+
+ return { rebuildMetadataEdit, applyMetadataEdit };
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/useEditStatus.ts b/frontend/src/react/components/SchemaEditorLite/useEditStatus.ts
new file mode 100644
index 0000000000..eff04b638a
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/useEditStatus.ts
@@ -0,0 +1,215 @@
+import { useCallback, useMemo, useRef, useState } from "react";
+import { keyForResource } from "@/components/SchemaEditorLite/context/common";
+import type { EditStatus } from "@/components/SchemaEditorLite/types";
+import type {
+ ColumnMetadata,
+ Database,
+ FunctionMetadata,
+ ProcedureMetadata,
+ SchemaMetadata,
+ TableMetadata,
+ TablePartitionMetadata,
+ ViewMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import type { EditStatusContext, SchemaResourceMetadata } from "./types";
+
+export function useEditStatus(): EditStatusContext {
+ const dirtyPathsRef = useRef(new Map<string, EditStatus>());
+ const [version, setVersion] = useState(0);
+ const bump = useCallback(() => setVersion((v) => v + 1), []);
+
+ // version is used as a dependency to re-derive when dirtyPaths mutates
+ const dirtyPathsArray = useMemo(
+ () => Array.from(dirtyPathsRef.current.keys()),
+ [version]
+ );
+
+ const isDirty = useMemo(() => dirtyPathsRef.current.size > 0, [version]);
+
+ const markEditStatus = useCallback(
+ (
+ database: Database,
+ metadata: SchemaResourceMetadata,
+ status: EditStatus
+ ) => {
+ const key = keyForResource(database, metadata);
+ dirtyPathsRef.current.set(key, status);
+ bump();
+ },
+ [bump]
+ );
+
+ const markEditStatusByKey = useCallback(
+ (key: string, status: EditStatus) => {
+ dirtyPathsRef.current.set(key, status);
+ bump();
+ },
+ [bump]
+ );
+
+ const getEditStatusByKey = useCallback((key: string) => {
+ return dirtyPathsRef.current.get(key);
+ }, []);
+
+ const removeEditStatus = useCallback(
+ (
+ database: Database,
+ metadata: SchemaResourceMetadata,
+ recursive: boolean
+ ) => {
+ const key = keyForResource(database, metadata);
+ if (recursive) {
+ const keys = Array.from(dirtyPathsRef.current.keys()).filter(
+ (path) => path === key || path.startsWith(`${key}/`)
+ );
+ keys.forEach((k) => dirtyPathsRef.current.delete(k));
+ } else {
+ dirtyPathsRef.current.delete(key);
+ }
+ bump();
+ },
+ [bump]
+ );
+
+ const clearEditStatus = useCallback(() => {
+ dirtyPathsRef.current.clear();
+ bump();
+ }, [bump]);
+
+ const getResourceStatus = useCallback(
+ (key: string, checkChildren: boolean): EditStatus => {
+ const status = dirtyPathsRef.current.get(key);
+ if (status) return status;
+ if (
+ checkChildren &&
+ dirtyPathsArray.some((path) => path.startsWith(`${key}/`))
+ ) {
+ return "updated";
+ }
+ return "normal";
+ },
+ [dirtyPathsArray]
+ );
+
+ const getSchemaStatus = useCallback(
+ (database: Database, metadata: { schema: SchemaMetadata }): EditStatus => {
+ return getResourceStatus(keyForResource(database, metadata), true);
+ },
+ [getResourceStatus]
+ );
+
+ const getTableStatus = useCallback(
+ (
+ database: Database,
+ metadata: { schema: SchemaMetadata; table: TableMetadata }
+ ): EditStatus => {
+ return getResourceStatus(keyForResource(database, metadata), true);
+ },
+ [getResourceStatus]
+ );
+
+ const getColumnStatus = useCallback(
+ (
+ database: Database,
+ metadata: {
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ }
+ ): EditStatus => {
+ return getResourceStatus(keyForResource(database, metadata), true);
+ },
+ [getResourceStatus]
+ );
+
+ const getPartitionStatus = useCallback(
+ (
+ database: Database,
+ metadata: {
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ partition: TablePartitionMetadata;
+ }
+ ): EditStatus => {
+ return getResourceStatus(keyForResource(database, metadata), true);
+ },
+ [getResourceStatus]
+ );
+
+ const getProcedureStatus = useCallback(
+ (
+ database: Database,
+ metadata: { schema: SchemaMetadata; procedure: ProcedureMetadata }
+ ): EditStatus => {
+ return getResourceStatus(keyForResource(database, metadata), false);
+ },
+ [getResourceStatus]
+ );
+
+ const getFunctionStatus = useCallback(
+ (
+ database: Database,
+ metadata: { schema: SchemaMetadata; function: FunctionMetadata }
+ ): EditStatus => {
+ return getResourceStatus(keyForResource(database, metadata), false);
+ },
+ [getResourceStatus]
+ );
+
+ const getViewStatus = useCallback(
+ (
+ database: Database,
+ metadata: { schema: SchemaMetadata; view: ViewMetadata }
+ ): EditStatus => {
+ return getResourceStatus(keyForResource(database, metadata), false);
+ },
+ [getResourceStatus]
+ );
+
+ const replaceTableName = useCallback(
+ (
+ database: Database,
+ metadata: { schema: SchemaMetadata; table: TableMetadata },
+ newName: string
+ ) => {
+ const key = keyForResource(database, metadata);
+ const sections = key.split("/");
+ sections.pop();
+ sections.push(newName);
+ const newKey = sections.join("/");
+ if (key === newKey) return;
+
+ const pathMap = new Map<string, string>();
+ for (const path of dirtyPathsRef.current.keys()) {
+ if (path.startsWith(key)) {
+ pathMap.set(path, path.replace(key, newKey));
+ }
+ }
+
+ for (const [oldPath, newPath] of pathMap.entries()) {
+ const status = dirtyPathsRef.current.get(oldPath)!;
+ dirtyPathsRef.current.delete(oldPath);
+ dirtyPathsRef.current.set(newPath, status);
+ }
+ bump();
+ },
+ [bump]
+ );
+
+ return {
+ isDirty,
+ markEditStatus,
+ markEditStatusByKey,
+ getEditStatusByKey,
+ removeEditStatus,
+ clearEditStatus,
+ getSchemaStatus,
+ getTableStatus,
+ getColumnStatus,
+ getPartitionStatus,
+ getProcedureStatus,
+ getFunctionStatus,
+ getViewStatus,
+ replaceTableName,
+ };
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/useScrollStatus.ts b/frontend/src/react/components/SchemaEditorLite/useScrollStatus.ts
new file mode 100644
index 0000000000..077be98c07
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/useScrollStatus.ts
@@ -0,0 +1,113 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import type {
+ RichColumnMetadata,
+ RichMetadataWithDB,
+ RichSchemaMetadata,
+ RichTableMetadata,
+ ScrollStatusContext,
+} from "./types";
+
+export function useScrollStatus(): ScrollStatusContext {
+ const [pendingScrollToTable, setPendingScrollToTable] = useState<
+ RichMetadataWithDB<RichTableMetadata> | undefined
+ >();
+ const [pendingScrollToColumn, setPendingScrollToColumn] = useState<
+ RichMetadataWithDB<RichColumnMetadata> | undefined
+ >();
+
+ const queuePendingScrollToTable = useCallback(
+ (params: RichMetadataWithDB<RichTableMetadata>) => {
+ requestAnimationFrame(() => {
+ setPendingScrollToTable(params);
+ });
+ },
+ []
+ );
+
+ const queuePendingScrollToColumn = useCallback(
+ (params: RichMetadataWithDB<RichColumnMetadata>) => {
+ requestAnimationFrame(() => {
+ setPendingScrollToColumn(params);
+ });
+ },
+ []
+ );
+
+ const consumePendingScrollToTable = useCallback(() => {
+ setPendingScrollToTable(undefined);
+ }, []);
+
+ const consumePendingScrollToColumn = useCallback(() => {
+ setPendingScrollToColumn(undefined);
+ }, []);
+
+ return {
+ pendingScrollToTable,
+ pendingScrollToColumn,
+ queuePendingScrollToTable,
+ queuePendingScrollToColumn,
+ consumePendingScrollToTable,
+ consumePendingScrollToColumn,
+ };
+}
+
+/**
+ * Hook to consume a pending scroll-to-table event when the condition matches.
+ * Replaces the Vue `useConsumePendingScrollToTable` composable.
+ */
+export function useConsumePendingScrollToTable(
+ condition: RichMetadataWithDB<RichSchemaMetadata> | undefined,
+ pending: RichMetadataWithDB<RichTableMetadata> | undefined,
+ consume: () => void,
+ fn: (params: RichMetadataWithDB<RichTableMetadata>) => void
+) {
+ const mountedRef = useRef(false);
+
+ useEffect(() => {
+ mountedRef.current = true;
+ }, []);
+
+ useEffect(() => {
+ if (!mountedRef.current) return;
+ if (!pending) return;
+ if (!condition) return;
+ if (
+ pending.db.name === condition.db.name &&
+ pending.metadata.schema.name === condition.metadata.schema.name
+ ) {
+ fn(pending);
+ consume();
+ }
+ }, [pending, condition, fn, consume]);
+}
+
+/**
+ * Hook to consume a pending scroll-to-column event when the condition matches.
+ * Replaces the Vue `useConsumePendingScrollToColumn` composable.
+ */
+export function useConsumePendingScrollToColumn(
+ condition: RichMetadataWithDB<RichTableMetadata> | undefined,
+ pending: RichMetadataWithDB<RichColumnMetadata> | undefined,
+ consume: () => void,
+ fn: (params: RichMetadataWithDB<RichColumnMetadata>) => void
+) {
+ const mountedRef = useRef(false);
+
+ useEffect(() => {
+ mountedRef.current = true;
+ }, []);
+
+ useEffect(() => {
+ if (!mountedRef.current) return;
+ if (!pending) return;
+ if (!condition) return;
+ if (
+ pending.db.name === condition.db.name &&
+ pending.metadata.schema.name === condition.metadata.schema.name &&
+ pending.metadata.table.name === condition.metadata.table.name
+ ) {
+ fn(pending);
+ consume();
+ }
+ }, [pending, condition, fn, consume]);
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/useSelection.ts b/frontend/src/react/components/SchemaEditorLite/useSelection.ts
new file mode 100644
index 0000000000..d2127b5020
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/useSelection.ts
@@ -0,0 +1,583 @@
+import { pick } from "lodash-es";
+import { useCallback, useMemo } from "react";
+import { keyForResource } from "@/components/SchemaEditorLite/context/common";
+import type { RolloutObject } from "@/components/SchemaEditorLite/types";
+import type {
+ ColumnMetadata,
+ Database,
+ DatabaseMetadata,
+ FunctionMetadata,
+ ProcedureMetadata,
+ SchemaMetadata,
+ TableMetadata,
+ ViewMetadata,
+} from "@/types/proto-es/v1/database_service_pb";
+import type { SelectionContext, SelectionState } from "./types";
+
+const EMPTY_STATE: SelectionState = { checked: false, indeterminate: false };
+
+export function useSelection(
+ selectedRolloutObjects: RolloutObject[] | undefined,
+ onSelectedRolloutObjectsChange?: (objects: RolloutObject[]) => void
+): SelectionContext {
+ const selectionEnabled = selectedRolloutObjects !== undefined;
+
+ const selectedRolloutObjectMap = useMemo(() => {
+ return new Map(
+ selectedRolloutObjects?.map((ro) => {
+ const key = keyForResource(ro.db, ro.metadata);
+ return [key, ro] as const;
+ })
+ );
+ }, [selectedRolloutObjects]);
+
+ const emit = useCallback(
+ (map: Map<string, RolloutObject>) => {
+ onSelectedRolloutObjectsChange?.(Array.from(map.values()));
+ },
+ [onSelectedRolloutObjectsChange]
+ );
+
+ // --- Table ---
+
+ const updateTableSelectionImpl = useCallback(
+ (
+ map: Map<string, RolloutObject>,
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ },
+ on: boolean
+ ) => {
+ const { table } = metadata;
+ if (on) {
+ map.set(keyForResource(db, metadata), { db, metadata });
+ table.columns.forEach((column) => {
+ map.set(keyForResource(db, { ...metadata, column }), {
+ db,
+ metadata: { ...metadata, column },
+ });
+ });
+ } else {
+ map.delete(keyForResource(db, metadata));
+ table.columns.forEach((column) => {
+ map.delete(keyForResource(db, { ...metadata, column }));
+ });
+ }
+ },
+ []
+ );
+
+ const updateColumnSelectionImpl = useCallback(
+ (
+ map: Map<string, RolloutObject>,
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ },
+ on: boolean
+ ) => {
+ const tableMeta = pick(metadata, "database", "schema", "table");
+ if (on) {
+ map.set(keyForResource(db, tableMeta), { db, metadata: tableMeta });
+ map.set(keyForResource(db, metadata), { db, metadata });
+ } else {
+ map.delete(keyForResource(db, metadata));
+ }
+ },
+ []
+ );
+
+ const updateSimpleSelectionImpl = useCallback(
+ (
+ map: Map<string, RolloutObject>,
+ db: Database,
+ metadata: Record<string, unknown>,
+ on: boolean
+ ) => {
+ const key = keyForResource(
+ db,
+ metadata as Parameters<typeof keyForResource>[1]
+ );
+ if (on) {
+ map.set(key, {
+ db,
+ metadata: metadata as RolloutObject["metadata"],
+ });
+ } else {
+ map.delete(key);
+ }
+ },
+ []
+ );
+
+ // Table selection
+ const getTableSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ }
+ ): SelectionState => {
+ if (!selectionEnabled) return EMPTY_STATE;
+ const { table } = metadata;
+ const tableChecked = selectedRolloutObjectMap.has(
+ keyForResource(db, metadata)
+ );
+ if (table.columns.length === 0) {
+ return { checked: tableChecked, indeterminate: false };
+ }
+ const checkedColumns = table.columns.filter((column) =>
+ selectedRolloutObjectMap.has(
+ keyForResource(db, { ...metadata, column })
+ )
+ );
+ const checked = checkedColumns.length === table.columns.length;
+ return {
+ checked,
+ indeterminate: !checked && (tableChecked || checkedColumns.length > 0),
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateTableSelection = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ },
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ updateTableSelectionImpl(updatedMap, db, metadata, on);
+ emit(updatedMap);
+ },
+ [selectionEnabled, selectedRolloutObjectMap, updateTableSelectionImpl, emit]
+ );
+
+ const getAllTablesSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ tables: TableMetadata[]
+ ): SelectionState => {
+ if (!selectionEnabled || tables.length === 0) return EMPTY_STATE;
+ const selected = tables.filter((table) =>
+ selectedRolloutObjectMap.has(keyForResource(db, { ...metadata, table }))
+ );
+ return {
+ checked: selected.length === tables.length,
+ indeterminate: selected.length > 0 && selected.length < tables.length,
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateAllTablesSelection = useCallback(
+ (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ tables: TableMetadata[],
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ tables.forEach((table) => {
+ updateTableSelectionImpl(updatedMap, db, { ...metadata, table }, on);
+ });
+ emit(updatedMap);
+ },
+ [selectionEnabled, selectedRolloutObjectMap, updateTableSelectionImpl, emit]
+ );
+
+ // Column selection
+ const getColumnSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ }
+ ): SelectionState => {
+ if (!selectionEnabled) return EMPTY_STATE;
+ const checked = selectedRolloutObjectMap.has(
+ keyForResource(db, metadata)
+ );
+ return { checked, indeterminate: false };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateColumnSelection = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ column: ColumnMetadata;
+ },
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ updateColumnSelectionImpl(updatedMap, db, metadata, on);
+ emit(updatedMap);
+ },
+ [
+ selectionEnabled,
+ selectedRolloutObjectMap,
+ updateColumnSelectionImpl,
+ emit,
+ ]
+ );
+
+ const getAllColumnsSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ },
+ columns: ColumnMetadata[]
+ ): SelectionState => {
+ if (!selectionEnabled || columns.length === 0) return EMPTY_STATE;
+ const selected = columns.filter((column) =>
+ selectedRolloutObjectMap.has(
+ keyForResource(db, { ...metadata, column })
+ )
+ );
+ return {
+ checked: selected.length === columns.length,
+ indeterminate: selected.length > 0 && selected.length < columns.length,
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateAllColumnsSelection = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ table: TableMetadata;
+ },
+ columns: ColumnMetadata[],
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ columns.forEach((column) => {
+ updateColumnSelectionImpl(updatedMap, db, { ...metadata, column }, on);
+ });
+ emit(updatedMap);
+ },
+ [
+ selectionEnabled,
+ selectedRolloutObjectMap,
+ updateColumnSelectionImpl,
+ emit,
+ ]
+ );
+
+ // View selection
+ const getViewSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ view: ViewMetadata;
+ }
+ ): SelectionState => {
+ if (!selectionEnabled) return EMPTY_STATE;
+ return {
+ checked: selectedRolloutObjectMap.has(keyForResource(db, metadata)),
+ indeterminate: false,
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateViewSelection = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ view: ViewMetadata;
+ },
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ updateSimpleSelectionImpl(updatedMap, db, metadata, on);
+ emit(updatedMap);
+ },
+ [
+ selectionEnabled,
+ selectedRolloutObjectMap,
+ updateSimpleSelectionImpl,
+ emit,
+ ]
+ );
+
+ const getAllViewsSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ views: ViewMetadata[]
+ ): SelectionState => {
+ if (!selectionEnabled || views.length === 0) return EMPTY_STATE;
+ const selected = views.filter((view) =>
+ selectedRolloutObjectMap.has(keyForResource(db, { ...metadata, view }))
+ );
+ return {
+ checked: selected.length === views.length,
+ indeterminate: selected.length > 0 && selected.length < views.length,
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateAllViewsSelection = useCallback(
+ (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ views: ViewMetadata[],
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ views.forEach((view) => {
+ updateSimpleSelectionImpl(updatedMap, db, { ...metadata, view }, on);
+ });
+ emit(updatedMap);
+ },
+ [
+ selectionEnabled,
+ selectedRolloutObjectMap,
+ updateSimpleSelectionImpl,
+ emit,
+ ]
+ );
+
+ // Procedure selection
+ const getProcedureSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ procedure: ProcedureMetadata;
+ }
+ ): SelectionState => {
+ if (!selectionEnabled) return EMPTY_STATE;
+ return {
+ checked: selectedRolloutObjectMap.has(keyForResource(db, metadata)),
+ indeterminate: false,
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateProcedureSelection = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ procedure: ProcedureMetadata;
+ },
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ updateSimpleSelectionImpl(updatedMap, db, metadata, on);
+ emit(updatedMap);
+ },
+ [
+ selectionEnabled,
+ selectedRolloutObjectMap,
+ updateSimpleSelectionImpl,
+ emit,
+ ]
+ );
+
+ const getAllProceduresSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ procedures: ProcedureMetadata[]
+ ): SelectionState => {
+ if (!selectionEnabled || procedures.length === 0) return EMPTY_STATE;
+ const selected = procedures.filter((procedure) =>
+ selectedRolloutObjectMap.has(
+ keyForResource(db, { ...metadata, procedure })
+ )
+ );
+ return {
+ checked: selected.length === procedures.length,
+ indeterminate:
+ selected.length > 0 && selected.length < procedures.length,
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateAllProceduresSelection = useCallback(
+ (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ procedures: ProcedureMetadata[],
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ procedures.forEach((procedure) => {
+ updateSimpleSelectionImpl(
+ updatedMap,
+ db,
+ { ...metadata, procedure },
+ on
+ );
+ });
+ emit(updatedMap);
+ },
+ [
+ selectionEnabled,
+ selectedRolloutObjectMap,
+ updateSimpleSelectionImpl,
+ emit,
+ ]
+ );
+
+ // Function selection
+ const getFunctionSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ function: FunctionMetadata;
+ }
+ ): SelectionState => {
+ if (!selectionEnabled) return EMPTY_STATE;
+ return {
+ checked: selectedRolloutObjectMap.has(keyForResource(db, metadata)),
+ indeterminate: false,
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateFunctionSelection = useCallback(
+ (
+ db: Database,
+ metadata: {
+ database: DatabaseMetadata;
+ schema: SchemaMetadata;
+ function: FunctionMetadata;
+ },
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ updateSimpleSelectionImpl(updatedMap, db, metadata, on);
+ emit(updatedMap);
+ },
+ [
+ selectionEnabled,
+ selectedRolloutObjectMap,
+ updateSimpleSelectionImpl,
+ emit,
+ ]
+ );
+
+ const getAllFunctionsSelectionState = useCallback(
+ (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ functions: FunctionMetadata[]
+ ): SelectionState => {
+ if (!selectionEnabled || functions.length === 0) return EMPTY_STATE;
+ const selected = functions.filter((func) =>
+ selectedRolloutObjectMap.has(
+ keyForResource(db, { ...metadata, function: func })
+ )
+ );
+ return {
+ checked: selected.length === functions.length,
+ indeterminate:
+ selected.length > 0 && selected.length < functions.length,
+ };
+ },
+ [selectionEnabled, selectedRolloutObjectMap]
+ );
+
+ const updateAllFunctionsSelection = useCallback(
+ (
+ db: Database,
+ metadata: { database: DatabaseMetadata; schema: SchemaMetadata },
+ functions: FunctionMetadata[],
+ on: boolean
+ ) => {
+ if (!selectionEnabled) return;
+ const updatedMap = new Map(selectedRolloutObjectMap.entries());
+ functions.forEach((func) => {
+ updateSimpleSelectionImpl(
+ updatedMap,
+ db,
+ { ...metadata, function: func },
+ on
+ );
+ });
+ emit(updatedMap);
+ },
+ [
+ selectionEnabled,
+ selectedRolloutObjectMap,
+ updateSimpleSelectionImpl,
+ emit,
+ ]
+ );
+
+ return {
+ selectionEnabled,
+ getTableSelectionState,
+ updateTableSelection,
+ getAllTablesSelectionState,
+ updateAllTablesSelection,
+ getColumnSelectionState,
+ updateColumnSelection,
+ getAllColumnsSelectionState,
+ updateAllColumnsSelection,
+ getViewSelectionState,
+ updateViewSelection,
+ getAllViewsSelectionState,
+ updateAllViewsSelection,
+ getProcedureSelectionState,
+ updateProcedureSelection,
+ getAllProceduresSelectionState,
+ updateAllProceduresSelection,
+ getFunctionSelectionState,
+ updateFunctionSelection,
+ getAllFunctionsSelectionState,
+ updateAllFunctionsSelection,
+ };
+}
diff --git a/frontend/src/react/components/SchemaEditorLite/useTabs.ts b/frontend/src/react/components/SchemaEditorLite/useTabs.ts
new file mode 100644
index 0000000000..a4f045f311
--- /dev/null
+++ b/frontend/src/react/components/SchemaEditorLite/useTabs.ts
@@ -0,0 +1,152 @@
+import { useCallback, useMemo, useRef, useState } from "react";
+import { v1 as uuidv1 } from "uuid";
+import type {
+ CoreTabContext,
+ TabContext,
+} from "@/components/SchemaEditorLite/types";
+import type { TabsContext } from "./types";
+
+export function useTabs(): TabsContext {
+ const tabMapRef = useRef(new Map<string, TabContext>());
+ const [currentTabId, setCurrentTabId] = useState("");
+ // Version counter to trigger re-renders when tabMap mutates.
+ const [, setVersion] = useState(0);
+ const bump = useCallback(() => setVersion((v) => v + 1), []);
+
+ // tabMapRef.current.size and currentTabId are deps to re-derive on mutations
+ const tabList = useMemo(
+ () => Array.from(tabMapRef.current.values()),
+ [tabMapRef.current.size, currentTabId]
+ );
+
+ const currentTab = useMemo(
+ () => (currentTabId ? tabMapRef.current.get(currentTabId) : undefined),
+ [currentTabId]
+ );
+
+ const findTab = useCallback(
+ (target: CoreTabContext): TabContext | undefined => {
+ for (const tab of tabMapRef.current.values()) {
+ if (tab.type !== target.type) continue;
+ if (tab.database.name !== target.database.name) continue;
+ if (tab.type === "database") {
+ if (tab.metadata.database.name === target.metadata.database.name) {
+ return tab;
+ }
+ }
+ // After the type guard above, both tab and target have the same type.
+ // We use `as any` on target.metadata to access the narrowed fields
+ // since TS can't narrow two variables from the same discriminant check.
+ const tabMeta = tab.metadata as Record<string, { name: string }>;
+ const targetMeta = target.metadata as Record<string, { name: string }>;
+ if (tab.type === "table") {
+ if (
+ tabMeta.schema.name === targetMeta.schema.name &&
+ tabMeta.table.name === targetMeta.table.name
+ ) {
+ return tab;
+ }
+ }
+ if (tab.type === "view") {
+ if (
+ tabMeta.schema.name === targetMeta.schema.name &&
+ tabMeta.view.name === targetMeta.view.name
+ ) {
+ return tab;
+ }
+ }
+ if (tab.type === "procedure") {
+ if (
+ tabMeta.schema.name === targetMeta.schema.name &&
+ tabMeta.procedure.name === targetMeta.procedure.name
+ ) {
+ return tab;
+ }
+ }
+ if (tab.type === "function") {
+ if (
+ tabMeta.schema.name === targetMeta.schema.name &&
+ tabMeta.function.name === targetMeta.function.name
+ ) {
+ return tab;
+ }
+ }
+ }
+ return undefined;
+ },
+ []
+ );
+
+ const addTab = useCallback(
+ (coreTab: CoreTabContext, setAsCurrentTab = true) => {
+ const existedTab = findTab(coreTab);
+ if (existedTab) {
+ Object.assign(existedTab, coreTab);
+ if (setAsCurrentTab) {
+ setCurrentTabId(existedTab.id);
+ }
+ bump();
+ return;
+ }
+
+ const id = uuidv1();
+ const tab: TabContext = { id, ...coreTab } as TabContext;
+ tabMapRef.current.set(id, tab);
+
+ if (setAsCurrentTab) {
+ requestAnimationFrame(() => {
+ setCurrentTabId(id);
+ });
+ }
+ bump();
+ },
+ [findTab, bump]
+ );
+
+ const setCurrentTab = useCallback((id: string) => {
+ if (tabMapRef.current.has(id)) {
+ setCurrentTabId(id);
+ } else {
+ setCurrentTabId("");
+ }
+ }, []);
+
+ const closeTab = useCallback(
+ (id: string) => {
+ const list = Array.from(tabMapRef.current.values());
+ const index = list.findIndex((tab) => tab.id === id);
+
+ if (currentTabId === id) {
+ let nextIndex = -1;
+ if (index === 0) {
+ nextIndex = 1;
+ } else {
+ nextIndex = index - 1;
+ }
+ const nextTab = list[nextIndex];
+ setCurrentTabId(nextTab ? nextTab.id : "");
+ }
+
+ tabMapRef.current.delete(id);
+ bump();
+ },
+ [currentTabId, bump]
+ );
+
+ const clearTabs = useCallback(() => {
+ tabMapRef.current.clear();
+ setCurrentTabId("");
+ bump();
+ }, [bump]);
+
+ return {
+ tabList,
+ currentTabId,
+ currentTab,
+ addTab,
+ setCurrentTab,
+ closeTab,
+ findTab,
+ clearTabs,
+ };
+}
diff --git a/frontend/src/react/locales/en-US.json b/frontend/src/react/locales/en-US.json
index 926bed7130..a699f9d5df 100644
--- a/frontend/src/react/locales/en-US.json
+++ b/frontend/src/react/locales/en-US.json
@@ -1581,7 +1581,67 @@
"task-execution-errors": "Task execution errors"
},
"schema-editor": {
- "raw-sql": "Raw SQL"
+ "actions": {
+ "add-column": "Add column",
+ "add-index": "Add index",
+ "add-partition": "Add partition",
+ "create-function": "Create function",
+ "create-procedure": "Create procedure",
+ "create-schema": "Create schema",
+ "create-table": "New table",
+ "create-view": "Create view",
+ "drop": "Drop",
+ "drop-schema": "Drop schema",
+ "drop-table": "Drop table",
+ "rename": "Rename",
+ "rename-table": "Rename table",
+ "restore": "Restore"
+ },
+ "column": {
+ "comment": "Comment",
+ "default": "Default",
+ "name": "Name",
+ "not-null": "Not Null",
+ "operations": "Operations",
+ "primary": "Primary",
+ "type": "Type"
+ },
+ "columns": "Columns",
+ "create-foreign-key": "Create Foreign Key",
+ "default": {
+ "placeholder": "Default value"
+ },
+ "edit-foreign-key": "Edit Foreign Key",
+ "foreign-key": {
+ "name": "Foreign Key Name",
+ "referenced-column": "Referenced Column",
+ "referenced-schema": "Referenced Schema",
+ "referenced-table": "Referenced Table"
+ },
+ "index": {
+ "columns": "Columns",
+ "primary": "Primary",
+ "unique": "Unique"
+ },
+ "indexes": "Indexes",
+ "partition": {
+ "expression": "Expression",
+ "type": "Type",
+ "value": "Value"
+ },
+ "partitions": "Partitions",
+ "preview": "Preview",
+ "raw-sql": "Raw SQL",
+ "schema": {
+ "duplicate-name": "Schema name already exists",
+ "name-placeholder": "Schema name"
+ },
+ "table": {
+ "duplicate-name": "Table name already exists",
+ "name-placeholder": "Table name",
+ "no-match": "No tables match the search",
+ "no-tables": "No tables"
+ }
},
"schema-template": {
"classification": {
diff --git a/frontend/src/react/locales/es-ES.json b/frontend/src/react/locales/es-ES.json
index 329e52d1fe..edc8655a0f 100644
--- a/frontend/src/react/locales/es-ES.json
+++ b/frontend/src/react/locales/es-ES.json
@@ -1581,7 +1581,67 @@
"task-execution-errors": "Errores de ejecución de tareas"
},
"schema-editor": {
- "raw-sql": "Raw SQL"
+ "actions": {
+ "add-column": "Add column",
+ "add-index": "Add index",
+ "add-partition": "Add partition",
+ "create-function": "Create function",
+ "create-procedure": "Create procedure",
+ "create-schema": "Create schema",
+ "create-table": "New table",
+ "create-view": "Create view",
+ "drop": "Drop",
+ "drop-schema": "Drop schema",
+ "drop-table": "Drop table",
+ "rename": "Rename",
+ "rename-table": "Rename table",
+ "restore": "Restore"
+ },
+ "column": {
+ "comment": "Comment",
+ "default": "Default",
+ "name": "Name",
+ "not-null": "Not Null",
+ "operations": "Operations",
+ "primary": "Primary",
+ "type": "Type"
+ },
+ "columns": "Columns",
+ "create-foreign-key": "Create Foreign Key",
+ "default": {
+ "placeholder": "Default value"
+ },
+ "edit-foreign-key": "Edit Foreign Key",
+ "foreign-key": {
+ "name": "Foreign Key Name",
+ "referenced-column": "Referenced Column",
+ "referenced-schema": "Referenced Schema",
+ "referenced-table": "Referenced Table"
+ },
+ "index": {
+ "columns": "Columns",
+ "primary": "Primary",
+ "unique": "Unique"
+ },
+ "indexes": "Indexes",
+ "partition": {
+ "expression": "Expression",
+ "type": "Type",
+ "value": "Value"
+ },
+ "partitions": "Partitions",
+ "preview": "Preview",
+ "raw-sql": "Raw SQL",
+ "schema": {
+ "duplicate-name": "Schema name already exists",
+ "name-placeholder": "Schema name"
+ },
+ "table": {
+ "duplicate-name": "Table name already exists",
+ "name-placeholder": "Table name",
+ "no-match": "No tables match the search",
+ "no-tables": "No tables"
+ }
},
"schema-template": {
"classification": {
diff --git a/frontend/src/react/locales/ja-JP.json b/frontend/src/react/locales/ja-JP.json
index bf8df4fb73..286c499cc6 100644
--- a/frontend/src/react/locales/ja-JP.json
+++ b/frontend/src/react/locales/ja-JP.json
@@ -1581,7 +1581,67 @@
"task-execution-errors": "タスク実行エラー"
},
"schema-editor": {
- "raw-sql": "Raw SQL"
+ "actions": {
+ "add-column": "Add column",
+ "add-index": "Add index",
+ "add-partition": "Add partition",
+ "create-function": "Create function",
+ "create-procedure": "Create procedure",
+ "create-schema": "Create schema",
+ "create-table": "New table",
+ "create-view": "Create view",
+ "drop": "Drop",
+ "drop-schema": "Drop schema",
+ "drop-table": "Drop table",
+ "rename": "Rename",
+ "rename-table": "Rename table",
+ "restore": "Restore"
+ },
+ "column": {
+ "comment": "Comment",
+ "default": "Default",
+ "name": "Name",
+ "not-null": "Not Null",
+ "operations": "Operations",
+ "primary": "Primary",
+ "type": "Type"
+ },
+ "columns": "Columns",
+ "create-foreign-key": "Create Foreign Key",
+ "default": {
+ "placeholder": "Default value"
+ },
+ "edit-foreign-key": "Edit Foreign Key",
+ "foreign-key": {
+ "name": "Foreign Key Name",
+ "referenced-column": "Referenced Column",
+ "referenced-schema": "Referenced Schema",
+ "referenced-table": "Referenced Table"
+ },
+ "index": {
+ "columns": "Columns",
+ "primary": "Primary",
+ "unique": "Unique"
+ },
+ "indexes": "Indexes",
+ "partition": {
+ "expression": "Expression",
+ "type": "Type",
+ "value": "Value"
+ },
+ "partitions": "Partitions",
+ "preview": "Preview",
+ "raw-sql": "Raw SQL",
+ "schema": {
+ "duplicate-name": "Schema name already exists",
+ "name-placeholder": "Schema name"
+ },
+ "table": {
+ "duplicate-name": "Table name already exists",
+ "name-placeholder": "Table name",
+ "no-match": "No tables match the search",
+ "no-tables": "No tables"
+ }
},
"schema-template": {
"classification": {
diff --git a/frontend/src/react/locales/vi-VN.json b/frontend/src/react/locales/vi-VN.json
index 7eb866bfc1..9b65f31c63 100644
--- a/frontend/src/react/locales/vi-VN.json
+++ b/frontend/src/react/locales/vi-VN.json
@@ -1581,7 +1581,67 @@
"task-execution-errors": "Lỗi thực hiện tác vụ"
},
"schema-editor": {
- "raw-sql": "Raw SQL"
+ "actions": {
+ "add-column": "Add column",
+ "add-index": "Add index",
+ "add-partition": "Add partition",
+ "create-function": "Create function",
+ "create-procedure": "Create procedure",
+ "create-schema": "Create schema",
+ "create-table": "New table",
+ "create-view": "Create view",
+ "drop": "Drop",
+ "drop-schema": "Drop schema",
+ "drop-table": "Drop table",
+ "rename": "Rename",
+ "rename-table": "Rename table",
+ "restore": "Restore"
+ },
+ "column": {
+ "comment": "Comment",
+ "default": "Default",
+ "name": "Name",
+ "not-null": "Not Null",
+ "operations": "Operations",
+ "primary": "Primary",
+ "type": "Type"
+ },
+ "columns": "Columns",
+ "create-foreign-key": "Create Foreign Key",
+ "default": {
+ "placeholder": "Default value"
+ },
+ "edit-foreign-key": "Edit Foreign Key",
+ "foreign-key": {
+ "name": "Foreign Key Name",
+ "referenced-column": "Referenced Column",
+ "referenced-schema": "Referenced Schema",
+ "referenced-table": "Referenced Table"
+ },
+ "index": {
+ "columns": "Columns",
+ "primary": "Primary",
+ "unique": "Unique"
+ },
+ "indexes": "Indexes",
+ "partition": {
+ "expression": "Expression",
+ "type": "Type",
+ "value": "Value"
+ },
+ "partitions": "Partitions",
+ "preview": "Preview",
+ "raw-sql": "Raw SQL",
+ "schema": {
+ "duplicate-name": "Schema name already exists",
+ "name-placeholder": "Schema name"
+ },
+ "table": {
+ "duplicate-name": "Table name already exists",
+ "name-placeholder": "Table name",
+ "no-match": "No tables match the search",
+ "no-tables": "No tables"
+ }
},
"schema-template": {
"classification": {
diff --git a/frontend/src/react/locales/zh-CN.json b/frontend/src/react/locales/zh-CN.json
index 0f48f3d44f..9ca0b0ade4 100644
--- a/frontend/src/react/locales/zh-CN.json
+++ b/frontend/src/react/locales/zh-CN.json
@@ -1581,7 +1581,67 @@
"task-execution-errors": "任务执行错误"
},
"schema-editor": {
- "raw-sql": "SQL 语句"
+ "actions": {
+ "add-column": "Add column",
+ "add-index": "Add index",
+ "add-partition": "Add partition",
+ "create-function": "Create function",
+ "create-procedure": "Create procedure",
+ "create-schema": "Create schema",
+ "create-table": "New table",
+ "create-view": "Create view",
+ "drop": "Drop",
+ "drop-schema": "Drop schema",
+ "drop-table": "Drop table",
+ "rename": "Rename",
+ "rename-table": "Rename table",
+ "restore": "Restore"
+ },
+ "column": {
+ "comment": "Comment",
+ "default": "Default",
+ "name": "Name",
+ "not-null": "Not Null",
+ "operations": "Operations",
+ "primary": "Primary",
+ "type": "Type"
+ },
+ "columns": "Columns",
+ "create-foreign-key": "Create Foreign Key",
+ "default": {
+ "placeholder": "Default value"
+ },
+ "edit-foreign-key": "Edit Foreign Key",
+ "foreign-key": {
+ "name": "Foreign Key Name",
+ "referenced-column": "Referenced Column",
+ "referenced-schema": "Referenced Schema",
+ "referenced-table": "Referenced Table"
+ },
+ "index": {
+ "columns": "Columns",
+ "primary": "Primary",
+ "unique": "Unique"
+ },
+ "indexes": "Indexes",
+ "partition": {
+ "expression": "Expression",
+ "type": "Type",
+ "value": "Value"
+ },
+ "partitions": "Partitions",
+ "preview": "Preview",
+ "raw-sql": "Raw SQL",
+ "schema": {
+ "duplicate-name": "Schema name already exists",
+ "name-placeholder": "Schema name"
+ },
+ "table": {
+ "duplicate-name": "Table name already exists",
+ "name-placeholder": "Table name",
+ "no-match": "No tables match the search",
+ "no-tables": "No tables"
+ }
},
"schema-template": {
"classification": {
diff --git a/frontend/tsconfig.app.json b/frontend/tsconfig.app.json
index 3dade12d5f..3c7a08a279 100644
--- a/frontend/tsconfig.app.json
+++ b/frontend/tsconfig.app.json
@@ -13,7 +13,13 @@
"src/react/components/MarkdownEditor/index.ts",
"src/react/components/task-run-log/index.ts",
"src/react/components/monaco/index.ts",
- "src/react/components/revision/index.ts"
+ "src/react/components/revision/index.ts",
+ "src/react/components/SchemaEditorLite/index.ts",
+ "src/react/components/SchemaEditorLite/Aside/index.ts",
+ "src/react/components/SchemaEditorLite/Panels/TableColumnEditor/index.ts",
+ "src/react/components/SchemaEditorLite/Panels/IndexesEditor/index.ts",
+ "src/react/components/SchemaEditorLite/Panels/PartitionsEditor/index.ts",
+ "src/react/components/SchemaEditorLite/Panels/TableList/index.ts"
],
"compilerOptions": {
"composite": true,
diff --git a/frontend/tsconfig.vitest.json b/frontend/tsconfig.vitest.json
index a631a90a49..aad6356059 100644
--- a/frontend/tsconfig.vitest.json
+++ b/frontend/tsconfig.vitest.json
@@ -12,7 +12,13 @@
"src/react/components/MarkdownEditor/index.ts",
"src/react/components/task-run-log/index.ts",
"src/react/components/monaco/index.ts",
- "src/react/components/revision/index.ts"
+ "src/react/components/revision/index.ts",
+ "src/react/components/SchemaEditorLite/index.ts",
+ "src/react/components/SchemaEditorLite/Aside/index.ts",
+ "src/react/components/SchemaEditorLite/Panels/TableColumnEditor/index.ts",
+ "src/react/components/SchemaEditorLite/Panels/IndexesEditor/index.ts",
+ "src/react/components/SchemaEditorLite/Panels/PartitionsEditor/index.ts",
+ "src/react/components/SchemaEditorLite/Panels/TableList/index.ts"
],
"compilerOptions": {
"composite": true,