@adecore/database 0.0.1 → 0.16.0-beta.0

package/dist/console/QueryConsole.js

@@ -0,0 +1,261 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useMemo, useRef, useState } from 'react';
+import clsx from 'clsx';
+import { Check, CircleAlert, History, Play, Square } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { Banner, Button, Icon, messageOf, PromptDialog, Spinner, Tabs, Tooltip } from '@adecore/ui';
+import { formatNumber } from '@adecore/ui/format';
+import { DatabaseRequestError } from '../client/types.js';
+import { useDatabaseClient, useDatabaseFiles } from '../client-context.js';
+import { splitStatements, statementAt } from '../sql-split.js';
+import { DestructiveDialog } from './DestructiveDialog.js';
+import { findDestructive } from './destructive.js';
+import { HistoryPanel } from './HistoryPanel.js';
+import { statementLabel } from './labels.js';
+import { isPageable, outcomeOf } from './outcome.js';
+import { SchemaPicker } from './SchemaPicker.js';
+import { orderSchemas } from './schemas.js';
+import { RUN_ALL_SHORTCUT, RUN_SHORTCUT } from './shortcuts.js';
+import { SqlEditor } from './SqlEditor.js';
+import { StatementResultView } from './StatementResultView.js';
+import { TransactionControls } from './TransactionControls.js';
+import { useConsoleHistory } from './useConsoleHistory.js';
+/* Rows in the first page of a result, and in every page after it. */
+const PAGE_SIZE = 500;
+const ranText = (ran, t) => {
+    switch (ran.kind) {
+        case 'statement':
+            return t('console.ranStatement', { statement: ran.label });
+        case 'selection':
+            return t('console.ranSelection');
+        case 'all':
+            return t('console.ranAll', { count: ran.count, formatted: formatNumber(ran.count) });
+    }
+};
+/* Type SQL, run it, and read what each statement did. Several statements give a tab each. */
+export function QueryConsole({ connection, schema, value, defaultValue = '', onValueChange, defaultHistoryOpen = false, autoFocus = false, className, ref }) {
+    const { t } = useTranslation('database');
+    const client = useDatabaseClient();
+    const files = useDatabaseFiles();
+    // A channel of its own, so a transaction a person starts here stays out of the table views and the designer.
+    const channel = `console:${useId()}`;
+    const session = useMemo(() => client.session(connection, channel), [client, connection, channel]);
+    const engine = connection.config.engine;
+    useEffect(() => () => {
+        void session.close();
+    }, [session]);
+    const history = useConsoleHistory(connection.id);
+    const running = useRef(null);
+    const generation = useRef(0);
+    const editor = useRef(null);
+    const [own, setOwn] = useState(defaultValue);
+    const [run, setRun] = useState({ status: 'idle' });
+    const [ran, setRan] = useState(null);
+    const [tab, setTab] = useState(0);
+    const [pages, setPages] = useState({});
+    const [paging, setPaging] = useState(false);
+    const [panelOpen, setPanelOpen] = useState(false);
+    const [historyOpen, setHistoryOpen] = useState(defaultHistoryOpen);
+    const [mode, setMode] = useState('auto');
+    const [inTransaction, setInTransaction] = useState(false);
+    const [settling, setSettling] = useState(false);
+    const [endingManual, setEndingManual] = useState(false);
+    const [confirming, setConfirming] = useState(null);
+    const [schemas, setSchemas] = useState([]);
+    const [seededSchema, setSeededSchema] = useState(schema);
+    const [pickedSchema, setPickedSchema] = useState(undefined);
+    const [exporting, setExporting] = useState(false);
+    const [notice, setNotice] = useState(null);
+    const sql = value ?? own;
+    const blank = sql.trim() === '';
+    const busy = run.status === 'running' || settling;
+    const activeSchema = pickedSchema ?? schema;
+    if (seededSchema !== schema) {
+        setSeededSchema(schema);
+        setPickedSchema(undefined);
+    }
+    useEffect(() => () => running.current?.abort(), []);
+    useEffect(() => {
+        if (autoFocus) {
+            editor.current?.focus();
+        }
+        // Only on mount: a console that later becomes active keeps the focus where the person put it.
+        // eslint-disable-next-line react/exhaustive-deps
+    }, []);
+    useEffect(() => {
+        if (engine !== 'mysql') {
+            return undefined;
+        }
+        const controller = new AbortController();
+        session
+            .schemas({ signal: controller.signal })
+            .then((list) => setSchemas(orderSchemas(list)))
+            .catch(() => undefined);
+        return () => controller.abort();
+    }, [engine, session]);
+    const changeSql = (next) => {
+        if (value === undefined) {
+            setOwn(next);
+        }
+        onValueChange?.(next);
+    };
+    const targetOf = (scope) => {
+        if (scope === 'all') {
+            const statements = splitStatements(sql, engine);
+            const [only] = statements;
+            if (only === undefined) {
+                return null;
+            }
+            return { sql, ran: statements.length > 1 ? { kind: 'all', count: statements.length } : { kind: 'statement', label: statementLabel(only.text) } };
+        }
+        const start = editor.current?.selectionStart ?? 0;
+        const end = editor.current?.selectionEnd ?? 0;
+        const selected = sql.slice(start, end);
+        if (splitStatements(selected, engine).length > 0) {
+            return { sql: selected, ran: { kind: 'selection' } };
+        }
+        const statement = statementAt(sql, start, engine);
+        return statement === null ? null : { sql: statement.text, ran: { kind: 'statement', label: statementLabel(statement.text) } };
+    };
+    const requestRun = (target) => {
+        if (target === null || busy) {
+            return;
+        }
+        const statements = findDestructive(target.sql, engine);
+        if (statements.length > 0) {
+            setConfirming({ target, statements });
+            return;
+        }
+        void execute(target);
+    };
+    const execute = async (target) => {
+        const controller = new AbortController();
+        const mine = ++generation.current;
+        running.current = controller;
+        setRun({ status: 'running' });
+        setRan(target.ran);
+        setNotice(null);
+        const record = (outcome) => history.record({ sql: target.sql, at: Date.now(), connection: connection.name, ...outcome });
+        try {
+            if (mode === 'manual' && !inTransaction) {
+                setInTransaction(await session.transaction('begin', { signal: controller.signal }));
+            }
+            const executed = await session.execute(target.sql, { schema: activeSchema, limit: PAGE_SIZE, signal: controller.signal });
+            if (controller.signal.aborted) {
+                setRun({ status: 'cancelled' });
+                return;
+            }
+            setInTransaction(executed.inTransaction);
+            setTab(0);
+            setPages({});
+            setRun({ status: 'done', results: executed.results });
+            record(outcomeOf(executed.results));
+        }
+        catch (error) {
+            if (controller.signal.aborted || (error instanceof DatabaseRequestError && error.code === 'cancelled')) {
+                setRun({ status: 'cancelled' });
+            }
+            else {
+                setRun({ status: 'failed', message: messageOf(error) });
+                record({ ok: false, rows: null });
+            }
+        }
+        finally {
+            if (generation.current === mine) {
+                running.current = null;
+            }
+        }
+    };
+    const pickHistory = (entry, runIt) => {
+        changeSql(entry.sql);
+        if (runIt) {
+            requestRun({ sql: entry.sql, ran: { kind: 'statement', label: statementLabel(entry.sql) } });
+        }
+    };
+    const settle = async (action) => {
+        setSettling(true);
+        try {
+            setInTransaction(await session.transaction(action));
+            return true;
+        }
+        catch (error) {
+            setNotice({ tone: 'error', message: messageOf(error) });
+            return false;
+        }
+        finally {
+            setSettling(false);
+        }
+    };
+    const settleAndGoAuto = async (action) => {
+        if (await settle(action)) {
+            setMode('auto');
+        }
+        setEndingManual(false);
+    };
+    const changeMode = (next) => {
+        if (next === 'auto' && inTransaction) {
+            setEndingManual(true);
+        }
+        else {
+            setMode(next);
+        }
+    };
+    const loadPage = async (index, result, offset) => {
+        const mine = generation.current;
+        setPaging(true);
+        setNotice(null);
+        try {
+            const rows = await session.page(result.sql, { schema: activeSchema, offset, limit: PAGE_SIZE });
+            if (generation.current === mine) {
+                setPages((current) => ({ ...current, [index]: { offset, rows } }));
+            }
+        }
+        catch (error) {
+            setNotice({ tone: 'error', message: messageOf(error) });
+        }
+        finally {
+            setPaging(false);
+        }
+    };
+    const exportResult = async (result, format) => {
+        if (files === undefined) {
+            return;
+        }
+        setExporting(true);
+        try {
+            const path = await files.save({ suggestedName: `result.${format}`, format });
+            if (path !== null) {
+                const exported = await session.export({ source: { kind: 'query', sql: result.sql, schema: activeSchema }, format, path });
+                setNotice({ tone: 'neutral', message: t('console.exported', { count: exported.rows, formatted: formatNumber(exported.rows) }) });
+            }
+        }
+        catch (error) {
+            setNotice({ tone: 'error', message: messageOf(error) });
+        }
+        finally {
+            setExporting(false);
+        }
+    };
+    const results = run.status === 'done' ? run.results : [];
+    const index = Math.min(tab, results.length - 1);
+    const base = results[index];
+    const page = pages[index];
+    const shown = base?.kind === 'rows' && page !== undefined ? { kind: 'rows', sql: base.sql, ...page.rows } : base;
+    const offset = page?.offset ?? 0;
+    const pager = base?.kind === 'rows' && shown?.kind === 'rows' && isPageable(base.sql, engine) && (shown.hasMore || offset > 0)
+        ? {
+            page: offset / PAGE_SIZE + 1,
+            loading: paging,
+            onPrevious: () => void loadPage(index, base, Math.max(0, offset - PAGE_SIZE)),
+            onNext: () => void loadPage(index, base, offset + PAGE_SIZE)
+        }
+        : undefined;
+    const exportBase = files !== undefined && base?.kind === 'rows' ? base : undefined;
+    return (_jsxs("div", { ref: ref, className: clsx('flex min-h-0 flex-col bg-surface text-text', className), children: [_jsxs("div", { className: "flex shrink-0 border-b border-border", children: [_jsxs("div", { className: "flex min-w-0 flex-1 flex-col gap-2 p-3", children: [_jsx(SqlEditor, { ref: editor, value: sql, onValueChange: changeSql, onRun: (scope) => requestRun(targetOf(scope)), label: t('console.editor'), placeholder: t('console.placeholder') }), _jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [run.status === 'running' ? (_jsxs(_Fragment, { children: [_jsxs(Button, { size: "sm", onClick: () => running.current?.abort(), children: [_jsx(Icon, { icon: Square, size: 12 }), t('console.cancel')] }), _jsx(Spinner, { size: 14, label: t('console.running') })] })) : (_jsxs(_Fragment, { children: [_jsx(Tooltip, { label: t('console.run'), kbd: RUN_SHORTCUT, children: _jsxs(Button, { variant: "primary", size: "sm", disabled: blank || busy, onClick: () => requestRun(targetOf('selection-or-statement')), children: [_jsx(Icon, { icon: Play, size: 12 }), t('console.run')] }) }), _jsx(Tooltip, { label: t('console.runAll'), kbd: RUN_ALL_SHORTCUT, children: _jsx(Button, { variant: "secondary", size: "sm", disabled: blank || busy, onClick: () => requestRun(targetOf('all')), children: t('console.runAll') }) })] })), _jsx(TransactionControls, { mode: mode, onModeChange: changeMode, open: inTransaction, busy: busy, onCommit: () => void settle('commit'), onRollback: () => void settle('rollback') }), ran !== null && run.status !== 'idle' && _jsx("span", { className: "min-w-0 truncate text-xs text-text-muted", children: ranText(ran, t) }), _jsxs("div", { className: "ml-auto flex items-center gap-2", children: [schemas.length > 0 && (_jsx(SchemaPicker, { schemas: schemas, value: activeSchema ?? null, disabled: busy, onValueChange: setPickedSchema })), _jsxs(Button, { size: "sm", "aria-pressed": historyOpen, className: "aria-pressed:bg-surface-active aria-pressed:text-text", onClick: () => setHistoryOpen(!historyOpen), children: [_jsx(Icon, { icon: History, size: 12 }), t('console.history.title')] })] })] })] }), historyOpen && _jsx(HistoryPanel, { entries: history.entries, onPick: pickHistory, onClear: history.clear })] }), run.status === 'failed' && _jsx(Banner, { icon: CircleAlert, tone: "error", message: run.message, className: "shrink-0 pt-2" }), run.status === 'cancelled' && _jsx(Banner, { icon: CircleAlert, tone: "neutral", message: t('console.cancelled'), className: "shrink-0 pt-2" }), notice !== null && (_jsx(Banner, { icon: notice.tone === 'error' ? CircleAlert : Check, tone: notice.tone, message: notice.message, className: "shrink-0 pt-2", children: _jsx(Button, { size: "xs", onClick: () => setNotice(null), children: t('console.dismiss') }) })), results.length > 1 && (_jsx(Tabs.Root, { value: tab, onValueChange: (next) => setTab(Number(next)), children: _jsx(Tabs.List, { className: "shrink-0 px-3", children: results.map((result, position) => (_jsx(Tabs.Tab, { value: position, children: statementLabel(result.sql) }, position))) }) })), shown !== undefined && (_jsx(StatementResultView, { result: shown, offset: offset, pager: pager, onExport: exportBase === undefined ? undefined : (format) => void exportResult(exportBase, format), exporting: exporting, engine: engine, valuePanelOpen: panelOpen, onValuePanelOpenChange: setPanelOpen }, `${index}:${offset}`)), _jsx(DestructiveDialog, { statements: confirming?.statements ?? [], onCancel: () => setConfirming(null), onConfirm: () => {
+                    const target = confirming?.target;
+                    setConfirming(null);
+                    if (target !== undefined) {
+                        void execute(target);
+                    }
+                } }), _jsx(PromptDialog, { open: endingManual, title: t('console.transaction.endTitle'), description: t('console.transaction.endDescription'), confirmLabel: t('console.transaction.commit'), secondary: { label: t('console.transaction.rollback'), onClick: () => void settleAndGoAuto('rollback') }, onConfirm: () => settleAndGoAuto('commit'), onOpenChange: () => setEndingManual(false) })] }));
+}

package/dist/console/SchemaPicker.d.ts

@@ -0,0 +1,11 @@
+import type { Ref } from 'react';
+import type { SchemaInfo } from '../protocol/index.ts';
+export interface SchemaPickerProps {
+    schemas: readonly SchemaInfo[];
+    value: string | null;
+    onValueChange(schema: string): void;
+    disabled?: boolean;
+    className?: string;
+    ref?: Ref<HTMLButtonElement>;
+}
+export declare function SchemaPicker({ schemas, value, onValueChange, disabled, className, ref }: SchemaPickerProps): import("react").JSX.Element;

package/dist/console/SchemaPicker.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useTranslation } from 'react-i18next';
+import { Select } from '@adecore/ui';
+/* Picks the schema the console's statements run in. */
+export function SchemaPicker({ schemas, value, onValueChange, disabled, className, ref }) {
+    const { t } = useTranslation('database');
+    return (_jsx(Select, { ref: ref, size: "sm", label: t('console.schema'), placeholder: t('console.schemaPlaceholder'), value: value, disabled: disabled, className: className, items: schemas.map((schema) => ({ value: schema.name, label: schema.name })), onValueChange: onValueChange }));
+}

package/dist/console/SqlEditor.d.ts

@@ -0,0 +1,12 @@
+import { type Ref } from 'react';
+export type RunScope = 'selection-or-statement' | 'all';
+export interface SqlEditorProps {
+    value: string;
+    onValueChange(value: string): void;
+    onRun(scope: RunScope): void;
+    label: string;
+    placeholder?: string;
+    className?: string;
+    ref?: Ref<HTMLTextAreaElement>;
+}
+export declare function SqlEditor({ value, onValueChange, onRun, label, placeholder, className, ref }: SqlEditorProps): import("react").JSX.Element;

package/dist/console/SqlEditor.js

@@ -0,0 +1,61 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+import { isApplePlatform, matchesShortcut, TextArea } from '@adecore/ui';
+import { applyEdit, indentEdit, newlineEdit, outdentEdit } from './editing.js';
+import { RUN_ALL_SHORTCUT, RUN_SHORTCUT } from './shortcuts.js';
+/*
+ * Where the SQL is typed. A plain text area for now, kept to itself so an editor with highlighting
+ * and completion can take its place without the console noticing: it needs only these props.
+ */
+export function SqlEditor({ value, onValueChange, onRun, label, placeholder, className, ref }) {
+    const pendingSelection = useRef(null);
+    useEffect(() => {
+        const pending = pendingSelection.current;
+        if (pending !== null) {
+            pendingSelection.current = null;
+            pending.area.setSelectionRange(pending.start, pending.end);
+        }
+    }, [value]);
+    // Through the browser's own insert, so Cmd+Z undoes the edit; the fallback sets the value itself.
+    const apply = (area, edit) => {
+        const before = area.value;
+        area.setSelectionRange(edit.from, edit.to);
+        const inserted = document.execCommand('insertText', false, edit.insert);
+        if (inserted && area.value === applyEdit(before, edit)) {
+            area.setSelectionRange(edit.selectionStart, edit.selectionEnd);
+            return;
+        }
+        pendingSelection.current = { area, start: edit.selectionStart, end: edit.selectionEnd };
+        onValueChange(applyEdit(before, edit));
+    };
+    const handleKeyDown = (event) => {
+        const apple = isApplePlatform();
+        if (matchesShortcut(RUN_ALL_SHORTCUT, event, apple)) {
+            event.preventDefault();
+            onRun('all');
+            return;
+        }
+        if (matchesShortcut(RUN_SHORTCUT, event, apple)) {
+            event.preventDefault();
+            onRun('selection-or-statement');
+            return;
+        }
+        if (event.nativeEvent.isComposing || event.metaKey || event.ctrlKey || event.altKey) {
+            return;
+        }
+        const area = event.currentTarget;
+        const { selectionStart, selectionEnd } = area;
+        if (event.key === 'Tab') {
+            event.preventDefault();
+            const edit = event.shiftKey ? outdentEdit(area.value, selectionStart, selectionEnd) : indentEdit(area.value, selectionStart, selectionEnd);
+            if (edit !== null) {
+                apply(area, edit);
+            }
+        }
+        else if (event.key === 'Enter' && !event.shiftKey) {
+            event.preventDefault();
+            apply(area, newlineEdit(area.value, selectionStart, selectionEnd));
+        }
+    };
+    return (_jsx(TextArea, { ref: ref, mono: true, resize: "vertical", "aria-label": label, placeholder: placeholder, spellCheck: false, autoCapitalize: "off", autoCorrect: "off", rows: 8, value: value, className: className, onChange: (event) => onValueChange(event.target.value), onKeyDown: handleKeyDown }));
+}

package/dist/console/StatementResultView.d.ts

@@ -0,0 +1,18 @@
+import type { Engine, FileFormat, StatementResult } from '../protocol/index.ts';
+export interface ResultPager {
+    readonly page: number;
+    readonly loading: boolean;
+    onPrevious(): void;
+    onNext(): void;
+}
+export interface StatementResultViewProps {
+    result: StatementResult;
+    offset?: number;
+    pager?: ResultPager;
+    onExport?(format: FileFormat): void;
+    exporting?: boolean;
+    engine?: Engine;
+    valuePanelOpen?: boolean;
+    onValuePanelOpenChange?(open: boolean): void;
+}
+export declare function StatementResultView({ result, offset, pager, onExport, exporting, engine, valuePanelOpen, onValuePanelOpenChange }: StatementResultViewProps): import("react").JSX.Element;

package/dist/console/StatementResultView.js

@@ -0,0 +1,32 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { ChevronLeft, ChevronRight, CircleAlert, Download, PanelRight } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { Banner, IconButton, Menu, Spinner } from '@adecore/ui';
+import { formatDecimal, formatNumber } from '@adecore/ui/format';
+import { DataGrid } from '../grid/DataGrid.js';
+import { previewValueOf } from '../grid/focused-value.js';
+import { ValueDock } from '../grid/ValueDock.js';
+import { ValuePanel } from '../value/ValuePanel.js';
+/* What "Copy as SQL INSERT" names the table of a result that comes from no table. */
+const RESULT_TABLE = 'result';
+const EXPORT_FORMATS = ['csv', 'tsv', 'json', 'sql'];
+/* One statement's outcome: a result set in a read-only grid, a count of affected rows, or the error the server gave. */
+export function StatementResultView({ result, offset = 0, pager, onExport, exporting = false, engine, valuePanelOpen = false, onValuePanelOpenChange }) {
+    const { t } = useTranslation('database');
+    const [focus, setFocus] = useState(null);
+    const rows = useMemo(() => (result.kind === 'rows' ? result.rows.map((cells, index) => ({ key: `row:${index}`, number: offset + index + 1, cells })) : []), [result, offset]);
+    const sqlTarget = useMemo(() => (engine === undefined ? undefined : { engine, table: RESULT_TABLE }), [engine]);
+    const elapsed = t('console.elapsed', { value: formatDecimal(result.elapsedMs) });
+    if (result.kind === 'error') {
+        return (_jsxs("div", { className: "flex min-h-0 flex-1 flex-col gap-3 p-3", children: [_jsx(Banner, { icon: CircleAlert, tone: "error", className: "min-w-0", message: _jsxs(_Fragment, { children: [result.error.message, result.error.sqlState !== undefined && (_jsx("span", { className: "ml-2 font-mono text-xs text-text-muted", children: t('console.sqlState', { state: result.error.sqlState }) }))] }) }), _jsx("p", { className: "px-1 text-xs text-text-muted tabular-nums", children: elapsed })] }));
+    }
+    if (result.kind === 'done') {
+        return (_jsxs("div", { className: "flex flex-col gap-1 p-4 text-sm text-text", children: [_jsx("p", { children: t('console.affected', { count: result.affected, formatted: formatNumber(result.affected) }) }), result.lastInsertId !== null && _jsx("p", { className: "text-xs text-text-muted", children: t('console.lastInsertId', { id: String(result.lastInsertId) }) }), _jsx("p", { className: "text-xs text-text-muted tabular-nums", children: elapsed })] }));
+    }
+    const focusedRow = valuePanelOpen && focus !== null ? rows.find((row) => row.key === focus.rowKey) : undefined;
+    const focusedCell = focus === null ? undefined : focusedRow?.cells[focus.column];
+    return (_jsxs(_Fragment, { children: [_jsx(ValueDock, { open: valuePanelOpen, panel: _jsx(ValuePanel, { column: focus === null ? null : (result.columns[focus.column] ?? null), value: focusedCell === undefined ? undefined : previewValueOf(focusedCell), loading: false, editable: false, onClose: () => onValuePanelOpenChange?.(false), className: "min-w-0 flex-1" }), children: _jsx(DataGrid, { label: t('console.result'), columns: result.columns, rows: rows, empty: t('console.noRows'), sqlTarget: sqlTarget, onFocusedCellChange: setFocus }) }), _jsxs("footer", { className: "flex h-10 shrink-0 items-center gap-4 border-t border-border px-3 text-xs text-text-muted", children: [_jsx("span", { className: "text-text tabular-nums", children: offset > 0 || pager !== undefined
+                            ? t('console.rowRange', { from: formatNumber(offset + Math.min(1, rows.length)), to: formatNumber(offset + rows.length) })
+                            : t('console.rows', { rows: formatNumber(result.rows.length) }) }), pager === undefined && result.hasMore && _jsx("span", { children: t('console.hasMore') }), _jsx("span", { className: "tabular-nums", children: elapsed }), _jsxs("span", { className: "ml-auto flex items-center gap-1", children: [pager !== undefined && (_jsxs(_Fragment, { children: [pager.loading && _jsx(Spinner, { size: 14, label: t('console.loading') }), _jsx(IconButton, { icon: ChevronLeft, size: "sm", label: t('console.previousPage'), disabled: pager.page <= 1 || pager.loading, onClick: pager.onPrevious }), _jsx("span", { className: "min-w-12 text-center tabular-nums", children: t('console.page', { page: formatNumber(pager.page) }) }), _jsx(IconButton, { icon: ChevronRight, size: "sm", label: t('console.nextPage'), disabled: !result.hasMore || pager.loading, onClick: pager.onNext })] })), onExport !== undefined && (_jsxs(Menu.Root, { children: [_jsx(IconButton, { icon: Download, size: "sm", label: t('console.export'), disabled: exporting, render: _jsx(Menu.Trigger, {}) }), _jsx(Menu.Popup, { children: EXPORT_FORMATS.map((format) => (_jsx(Menu.Item, { onClick: () => onExport(format), children: t('console.exportAs', { format: format.toUpperCase() }) }, format))) })] })), onValuePanelOpenChange !== undefined && (_jsx(IconButton, { icon: PanelRight, size: "sm", label: t('console.valuePanel'), "aria-pressed": valuePanelOpen, onClick: () => onValuePanelOpenChange(!valuePanelOpen) }))] })] })] }));
+}

package/dist/console/TransactionControls.d.ts

@@ -0,0 +1,13 @@
+import type { Ref } from 'react';
+export type TransactionMode = 'auto' | 'manual';
+export interface TransactionControlsProps {
+    mode: TransactionMode;
+    onModeChange(mode: TransactionMode): void;
+    open: boolean;
+    busy: boolean;
+    onCommit(): void;
+    onRollback(): void;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function TransactionControls({ mode, onModeChange, open, busy, onCommit, onRollback, className, ref }: TransactionControlsProps): import("react").JSX.Element;

package/dist/console/TransactionControls.js

@@ -0,0 +1,12 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import clsx from 'clsx';
+import { useTranslation } from 'react-i18next';
+import { Button, Pill, Segmented, Tooltip } from '@adecore/ui';
+/* Auto or manual commits, and while a transaction is open, the way to end it. */
+export function TransactionControls({ mode, onModeChange, open, busy, onCommit, onRollback, className, ref }) {
+    const { t } = useTranslation('database');
+    return (_jsxs("div", { ref: ref, className: clsx('flex items-center gap-2', className), children: [_jsx(Tooltip, { label: t('console.transaction.hint'), children: _jsx("div", { className: "flex", children: _jsx(Segmented, { value: mode, onValueChange: onModeChange, disabled: busy, label: t('console.transaction.mode'), options: [
+                            { id: 'auto', label: t('console.transaction.auto') },
+                            { id: 'manual', label: t('console.transaction.manual') }
+                        ] }) }) }), open && (_jsxs(_Fragment, { children: [_jsx(Pill, { tone: "needsYou", children: t('console.transaction.open') }), _jsx(Button, { size: "xs", variant: "secondary", disabled: busy, onClick: onCommit, children: t('console.transaction.commit') }), _jsx(Button, { size: "xs", variant: "danger-outline", disabled: busy, onClick: onRollback, children: t('console.transaction.rollback') })] }))] }));
+}

package/dist/console/destructive.d.ts

@@ -0,0 +1,7 @@
+import type { Engine } from '../protocol/index.ts';
+export type DestructiveKind = 'drop' | 'truncate' | 'delete' | 'update' | 'alterDrop';
+export interface DestructiveStatement {
+    readonly sql: string;
+    readonly kind: DestructiveKind;
+}
+export declare const findDestructive: (sql: string, engine: Engine) => DestructiveStatement[];

package/dist/console/destructive.js

@@ -0,0 +1,43 @@
+import { splitStatements, tokenize } from '../sql-split.js';
+const wordsOf = (sql, engine) => {
+    const words = [];
+    let depth = 0;
+    for (const token of tokenize(sql, engine)) {
+        const text = sql.slice(token.start, token.end);
+        if (token.kind === 'word') {
+            words.push({ word: text.toUpperCase(), depth });
+        }
+        else if (token.kind === 'punct' && text === '(') {
+            depth += 1;
+        }
+        else if (token.kind === 'punct' && text === ')') {
+            depth = Math.max(0, depth - 1);
+        }
+    }
+    return words;
+};
+const kindOf = (sql, engine) => {
+    const words = wordsOf(sql, engine);
+    const first = words[0]?.word;
+    if (first === 'DROP') {
+        return 'drop';
+    }
+    if (first === 'TRUNCATE') {
+        return 'truncate';
+    }
+    if (first === 'ALTER') {
+        return words.some(({ word }) => word === 'DROP') ? 'alterDrop' : null;
+    }
+    // A statement behind a `WITH` is the first DELETE or UPDATE outside any parentheses.
+    const writer = first === 'WITH' ? words.find(({ word, depth }) => depth === 0 && (word === 'DELETE' || word === 'UPDATE')) : words[0];
+    if (writer?.word !== 'DELETE' && writer?.word !== 'UPDATE') {
+        return null;
+    }
+    const filtered = words.some(({ word, depth }) => word === 'WHERE' && depth === 0);
+    return filtered ? null : writer.word === 'DELETE' ? 'delete' : 'update';
+};
+/* The statements of a script that drop, truncate, or delete or update without a `WHERE`. */
+export const findDestructive = (sql, engine) => splitStatements(sql, engine).flatMap((statement) => {
+    const kind = kindOf(statement.text, engine);
+    return kind === null ? [] : [{ sql: statement.text, kind }];
+});

package/dist/console/editing.d.ts

@@ -0,0 +1,12 @@
+export interface TextEdit {
+    readonly from: number;
+    readonly to: number;
+    readonly insert: string;
+    readonly selectionStart: number;
+    readonly selectionEnd: number;
+}
+export declare const INDENT = "    ";
+export declare const applyEdit: (value: string, edit: TextEdit) => string;
+export declare const indentEdit: (value: string, start: number, end: number) => TextEdit;
+export declare const outdentEdit: (value: string, start: number, end: number) => TextEdit | null;
+export declare const newlineEdit: (value: string, start: number, end: number) => TextEdit;

package/dist/console/editing.js

@@ -0,0 +1,60 @@
+export const INDENT = '    ';
+export const applyEdit = (value, edit) => value.slice(0, edit.from) + edit.insert + value.slice(edit.to);
+const lineStartOf = (value, at) => value.lastIndexOf('\n', at - 1) + 1;
+const lineEndOf = (value, at) => {
+    const newline = value.indexOf('\n', at);
+    return newline === -1 ? value.length : newline;
+};
+/* The whitespace a line begins with. */
+const indentOf = (line) => /^[ \t]*/.exec(line)[0];
+/* The lines a selection touches. A selection that ends at the start of a line leaves that line out. */
+const touchedLines = (value, start, end) => {
+    const from = lineStartOf(value, start);
+    const last = end > start && value[end - 1] === '\n' ? end - 1 : end;
+    return { from, to: lineEndOf(value, last) };
+};
+/* Tab: four spaces at the caret, or one indent level on every touched line when the selection spans lines. */
+export const indentEdit = (value, start, end) => {
+    if (!value.slice(start, end).includes('\n')) {
+        return { from: start, to: end, insert: INDENT, selectionStart: start + INDENT.length, selectionEnd: start + INDENT.length };
+    }
+    const { from, to } = touchedLines(value, start, end);
+    const lines = value.slice(from, to).split('\n');
+    return {
+        from,
+        to,
+        insert: lines.map((line) => (line === '' ? line : INDENT + line)).join('\n'),
+        selectionStart: start + (lines[0] === '' ? 0 : INDENT.length),
+        selectionEnd: end + lines.filter((line) => line !== '').length * INDENT.length
+    };
+};
+/* Shift+Tab: takes one level of indentation off every touched line, four spaces or one tab. */
+export const outdentEdit = (value, start, end) => {
+    const { from, to } = touchedLines(value, start, end);
+    const lines = value.slice(from, to).split('\n');
+    const removed = lines.map((line) => {
+        if (line.startsWith('\t')) {
+            return 1;
+        }
+        return Math.min(INDENT.length, /^ */.exec(line)[0].length);
+    });
+    const total = removed.reduce((sum, count) => sum + count, 0);
+    if (total === 0) {
+        return null;
+    }
+    const firstLineStart = from;
+    return {
+        from,
+        to,
+        insert: lines.map((line, index) => line.slice(removed[index])).join('\n'),
+        selectionStart: Math.max(firstLineStart, start - removed[0]),
+        selectionEnd: Math.max(firstLineStart, end - total)
+    };
+};
+/* Enter: a new line that starts with the indentation of the line the caret is on, up to the caret. */
+export const newlineEdit = (value, start, end) => {
+    const lineStart = lineStartOf(value, start);
+    const indent = indentOf(value.slice(lineStart, start));
+    const insert = `\n${indent}`;
+    return { from: start, to: end, insert, selectionStart: start + insert.length, selectionEnd: start + insert.length };
+};

package/dist/console/history.d.ts

@@ -0,0 +1,13 @@
+export interface HistoryEntry {
+    readonly sql: string;
+    readonly at: number;
+    readonly connection: string;
+    readonly ok: boolean;
+    readonly rows: number | null;
+}
+export declare const HISTORY_LIMIT = 200;
+export declare const historyKey: (connectionId: string) => string;
+export declare const parseHistory: (raw: string | null) => HistoryEntry[];
+export declare const serializeHistory: (entries: readonly HistoryEntry[]) => string;
+export declare const addEntry: (entries: readonly HistoryEntry[], entry: HistoryEntry) => HistoryEntry[];
+export declare const searchHistory: (entries: readonly HistoryEntry[], query: string) => readonly HistoryEntry[];

package/dist/console/history.js

@@ -0,0 +1,43 @@
+export const HISTORY_LIMIT = 200;
+export const historyKey = (connectionId) => `database:console-history:${connectionId}`;
+const isEntry = (value) => {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const entry = value;
+    return (typeof entry.sql === 'string' &&
+        typeof entry.at === 'number' &&
+        typeof entry.connection === 'string' &&
+        typeof entry.ok === 'boolean' &&
+        (entry.rows === null || typeof entry.rows === 'number'));
+};
+/* Reads what `serializeHistory` wrote. Anything that does not fit gives an empty list, or leaves out the entries that do not fit. */
+export const parseHistory = (raw) => {
+    if (raw === null) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter(isEntry).slice(0, HISTORY_LIMIT) : [];
+    }
+    catch {
+        return [];
+    }
+};
+export const serializeHistory = (entries) => JSON.stringify(entries);
+/* The list with the run in front. A run of the same SQL as the latest one replaces it. */
+export const addEntry = (entries, entry) => {
+    const rest = entries[0]?.sql.trim() === entry.sql.trim() ? entries.slice(1) : entries;
+    return [entry, ...rest].slice(0, HISTORY_LIMIT);
+};
+/* The entries whose SQL holds every word of the query, in any case. */
+export const searchHistory = (entries, query) => {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+        return entries;
+    }
+    return entries.filter((entry) => {
+        const sql = entry.sql.toLowerCase();
+        return words.every((word) => sql.includes(word));
+    });
+};

package/dist/console/labels.d.ts

@@ -0,0 +1 @@
+export declare const statementLabel: (sql: string) => string;

package/dist/console/labels.js

@@ -0,0 +1,6 @@
+const LABEL_LENGTH = 32;
+/* The tab of a statement: its SQL on one line, cut where it gets long. */
+export const statementLabel = (sql) => {
+    const line = sql.replace(/\s+/g, ' ').trim();
+    return line.length > LABEL_LENGTH ? `${line.slice(0, LABEL_LENGTH - 1).trimEnd()}…` : line;
+};