sqlite-hub 0.11.1 → 0.16.0

package/frontend/js/store.js

@@ -7,6 +7,7 @@ import {
     hydrateTableDesignerDraft,
     removeTableDesignerColumn,
     updateTableDesignerColumnField,
+    updateTableDesignerConstraintField,
     updateTableDesignerDraftField,
 } from './utils/tableDesigner.js';
 import {
@@ -22,6 +23,7 @@ import {
     MEDIA_TAGGING_DEFAULT_MAPPING_TABLE,
     MEDIA_TAGGING_DEFAULT_TAG_TABLE,
 } from './lib/mediaTaggingDefaults.js';
+import { buildTextExportFilename } from './utils/exportFilenames.js';
 
 const listeners = new Set();
 const DEFAULT_SETTINGS = {
@@ -35,6 +37,9 @@ const DATA_FILTER_OPERATORS = new Set(['=', '!=', '<', '>', '<=', '>=', 'equals'
 const DATA_ROW_SIZE_STORAGE_KEY = 'data_row_size';
 const CHARTS_HISTORY_TAB_STORAGE_KEY = 'charts_history_tab';
 const QUERY_HISTORY_TAB_STORAGE_KEY = 'query_history_tab';
+const COPY_COLUMN_SEPARATOR_STORAGE_KEY = 'sqlitehub.copyColumn.separator';
+const COPY_COLUMN_WRAPPER_STORAGE_KEY = 'sqlitehub.copyColumn.wrapper';
+const COPY_COLUMN_LINE_BREAKS_STORAGE_KEY = 'sqlitehub.copyColumn.lineBreaks';
 const UI_PREFERENCE_STORAGE_KEYS = {
     sqlEditorHistoryVisible: 'sqlite_hub_sql_editor_history_visible',
     sqlEditorEditorVisible: 'sqlite_hub_sql_editor_editor_visible',
@@ -50,6 +55,12 @@ const QUERY_HISTORY_PAGE_SIZE = 30;
 const QUERY_HISTORY_RUN_LIMIT = 8;
 const CHART_HEIGHT_PRESETS = new Set(['small', 'medium', 'large']);
 const EDITOR_RESULT_TABS = new Set(['results', 'performance', 'messages']);
+const COPY_COLUMN_MODES = new Set(['column', 'column-with-header', 'first-10', 'markdown-todo']);
+const TEXT_EXPORT_FORMAT_LABELS = {
+    csv: 'CSV',
+    tsv: 'TSV',
+    md: 'Markdown',
+};
 const MISSING_DATABASE_ERROR = {
     code: 'ACTIVE_DATABASE_REQUIRED',
     message: 'No active SQLite database selected.',
@@ -79,6 +90,34 @@ function storeDataPageSize(pageSize) {
     }
 }
 
+function findQueryHistoryItemBySql(sql, snapshot = state) {
+    const normalizedSql = String(sql ?? '').trim();
+
+    if (!normalizedSql) {
+        return null;
+    }
+
+    if (String(snapshot.editor.historyDetail?.rawSql ?? '').trim() === normalizedSql) {
+        return snapshot.editor.historyDetail;
+    }
+
+    return snapshot.editor.history.find(entry => String(entry.rawSql ?? '').trim() === normalizedSql) ?? null;
+}
+
+function getCurrentQueryExportFilename(format = 'csv', filename = '') {
+    const queryText = String(state.editor.sqlText ?? '');
+    const historyItem = findQueryHistoryItemBySql(queryText);
+    const fallback = historyItem?.displayTitle || 'query-results';
+
+    return buildTextExportFilename(filename || fallback, { format, fallback });
+}
+
+function getCurrentDataTableExportFilename(format = 'csv', filename = '') {
+    const fallback = state.dataBrowser.selectedTable || 'table';
+
+    return buildTextExportFilename(filename || fallback, { format, fallback });
+}
+
 function readStoredBoolean(key, fallback) {
     try {
         const value = globalThis.localStorage?.getItem(key);
@@ -122,6 +161,27 @@ function storeString(key, value) {
     }
 }
 
+function readCopyColumnPreferences() {
+    return {
+        separator: readStoredString(COPY_COLUMN_SEPARATOR_STORAGE_KEY, ','),
+        wrapper: readStoredString(COPY_COLUMN_WRAPPER_STORAGE_KEY, '"'),
+        lineBreaks: readStoredBoolean(COPY_COLUMN_LINE_BREAKS_STORAGE_KEY, false),
+    };
+}
+
+function normalizeCopyColumnMode(mode) {
+    const normalizedMode = String(mode ?? '').trim();
+    return COPY_COLUMN_MODES.has(normalizedMode) ? normalizedMode : 'column';
+}
+
+function normalizeCopyColumnScope(scope) {
+    return scope === 'charts' ? 'charts' : 'editor';
+}
+
+function getResultByCopyColumnScope(scope, snapshot = state) {
+    return normalizeCopyColumnScope(scope) === 'charts' ? snapshot.charts.result : snapshot.editor.result;
+}
+
 function readStoredEditorActiveTab(fallback = 'messages') {
     try {
         const value = globalThis.localStorage?.getItem(UI_PREFERENCE_STORAGE_KEYS.sqlEditorActiveTab);
@@ -1475,6 +1535,16 @@ async function resolvePendingDataBrowserRow(version) {
         return;
     }
 
+    if (!pendingTarget.identity && Number.isInteger(pendingTarget.rowIndex)) {
+        if (table.rows?.[pendingTarget.rowIndex]) {
+            state.dataBrowser.selectedRowIndex = pendingTarget.rowIndex;
+            state.dataBrowser.selectedRow = null;
+        }
+
+        state.dataBrowser.pendingOpenRow = null;
+        return;
+    }
+
     const matchingRowIndex = findDataBrowserRowIndexByIdentity(table.rows ?? [], pendingTarget.identity);
 
     if (matchingRowIndex >= 0) {
@@ -1978,14 +2048,20 @@ async function previewMediaTaggingDraft(options = {}) {
     }
 }
 
-function invalidateDatabaseCaches() {
+function invalidateDatabaseCaches(options = {}) {
+    const preserveDataBrowserState = options.preserveDataBrowserState === true;
+
     state.overview.data = null;
     state.dataBrowser.tables = [];
-    state.dataBrowser.selectedTable = null;
+    if (!preserveDataBrowserState) {
+        state.dataBrowser.selectedTable = null;
+    }
     state.dataBrowser.table = null;
-    state.dataBrowser.page = 1;
-    resetDataBrowserTableSearch();
-    resetDataBrowserSearch();
+    if (!preserveDataBrowserState) {
+        state.dataBrowser.page = 1;
+        resetDataBrowserTableSearch();
+        resetDataBrowserSearch();
+    }
     clearDataBrowserRowSelectionState();
     state.dataBrowser.pendingOpenRow = null;
     state.dataBrowser.exportLoading = false;
@@ -2244,15 +2320,131 @@ export async function setRoute(route) {
     await loadRouteData(route);
 }
 
-export function openModal(kind) {
+export function openModal(kind, options = {}) {
     state.modal = {
         kind,
         error: null,
         submitting: false,
+        ...options,
+    };
+    emitChange();
+}
+
+export function openQueryExportModal() {
+    if (!String(state.editor.sqlText ?? '').trim()) {
+        pushToast('Enter a query before exporting.', 'alert');
+        return;
+    }
+
+    state.modal = {
+        kind: 'query-export',
+        filename: getCurrentQueryExportFilename('csv'),
+        error: null,
+        submitting: false,
+    };
+    emitChange();
+}
+
+export function openDataExportModal() {
+    if (!state.dataBrowser.selectedTable) {
+        pushToast('No table selected for export.', 'alert');
+        return;
+    }
+
+    state.modal = {
+        kind: 'data-export',
+        filename: getCurrentDataTableExportFilename('csv'),
+        error: null,
+        submitting: false,
     };
     emitChange();
 }
 
+export function openCopyColumnModal({ scope = 'editor', columnName = '', mode = 'column' } = {}) {
+    const resultScope = normalizeCopyColumnScope(scope);
+    const normalizedColumnName = String(columnName ?? '');
+    const result = getResultByCopyColumnScope(resultScope);
+    const hasColumn = (result?.columns ?? []).some(column => String(column) === normalizedColumnName);
+
+    if (!hasColumn) {
+        pushToast('Column could not be found in the current result set.', 'alert');
+        return;
+    }
+
+    const preferences = readCopyColumnPreferences();
+
+    state.modal = {
+        kind: 'copy-column',
+        scope: resultScope,
+        columnName: normalizedColumnName,
+        copyMode: normalizeCopyColumnMode(mode),
+        separator: preferences.separator,
+        wrapper: preferences.wrapper,
+        lineBreaks: preferences.lineBreaks,
+        error: null,
+        submitting: false,
+    };
+    emitChange();
+}
+
+export function storeCopyColumnPreferences({ separator = ',', wrapper = '"', lineBreaks = false } = {}) {
+    storeString(COPY_COLUMN_SEPARATOR_STORAGE_KEY, separator);
+    storeString(COPY_COLUMN_WRAPPER_STORAGE_KEY, wrapper);
+    storeBoolean(COPY_COLUMN_LINE_BREAKS_STORAGE_KEY, lineBreaks);
+
+    if (state.modal?.kind === 'copy-column') {
+        state.modal.separator = String(separator ?? '');
+        state.modal.wrapper = String(wrapper ?? '');
+        state.modal.lineBreaks = Boolean(lineBreaks);
+    }
+}
+
+export function updateCopyColumnModalFormatField(field, value) {
+    if (state.modal?.kind !== 'copy-column') {
+        return;
+    }
+
+    const normalizedField = String(field ?? '').trim();
+
+    if (normalizedField !== 'separator' && normalizedField !== 'wrapper' && normalizedField !== 'lineBreaks') {
+        return;
+    }
+
+    const normalizedValue = normalizedField === 'lineBreaks' ? Boolean(value) : String(value ?? '');
+    state.modal[normalizedField] = normalizedValue;
+    state.modal.error = null;
+
+    if (normalizedField === 'lineBreaks') {
+        storeBoolean(COPY_COLUMN_LINE_BREAKS_STORAGE_KEY, normalizedValue);
+    } else {
+        storeString(
+            normalizedField === 'separator' ? COPY_COLUMN_SEPARATOR_STORAGE_KEY : COPY_COLUMN_WRAPPER_STORAGE_KEY,
+            normalizedValue,
+        );
+    }
+    emitChange();
+}
+
+export function setCopyColumnModalSubmitting(submitting) {
+    if (state.modal?.kind !== 'copy-column') {
+        return;
+    }
+
+    state.modal.submitting = Boolean(submitting);
+    if (submitting) {
+        state.modal.error = null;
+    }
+    emitChange();
+}
+
+export function setCopyColumnModalError(error) {
+    if (state.modal?.kind !== 'copy-column') {
+        return;
+    }
+
+    withModalError(error);
+}
+
 export function openEditConnectionModal(id) {
     const connection = state.connections.recent.find(entry => entry.id === id);
 
@@ -2845,7 +3037,7 @@ export async function executeCurrentQuery() {
         state.editor.result = response.data;
         resetEditorResultSort();
         state.editor.error = null;
-        invalidateDatabaseCaches();
+        invalidateDatabaseCaches({ preserveDataBrowserState: true });
         await refreshQueryHistoryState();
         pushToast(response.message || `Executed ${response.data.statementCount} SQL statement(s).`, 'success');
         return true;
@@ -3143,6 +3335,26 @@ export function updateCurrentTableDesignerColumnField(columnId, field, value, op
     }
 }
 
+export function updateCurrentTableDesignerConstraintField(constraintKind, constraintId, field, value, options = {}) {
+    if (!state.tableDesigner.draft) {
+        return;
+    }
+
+    state.tableDesigner.draft = updateTableDesignerConstraintField(
+        state.tableDesigner.draft,
+        constraintKind,
+        constraintId,
+        field,
+        value,
+        getTableDesignerContext(),
+    );
+    state.tableDesigner.saveError = null;
+
+    if (options.notify !== false) {
+        emitChange();
+    }
+}
+
 export function addCurrentTableDesignerColumn() {
     if (!state.tableDesigner.draft) {
         return null;
@@ -3158,9 +3370,15 @@ export function addCurrentTableDesignerColumn() {
     return nextColumn?.id ?? null;
 }
 
-export function queueTableDesignerCsvImport(fileName, csvText) {
+export function queueTableDesignerCsvImport(fileName, csvText, options = {}) {
     try {
-        const imported = createTableDesignerDraftFromCsvImport({ fileName, csvText }, getTableDesignerContext());
+        const imported = createTableDesignerDraftFromCsvImport(
+            { fileName, csvText },
+            {
+                ...getTableDesignerContext(),
+                ...(options.context ?? {}),
+            },
+        );
 
         state.tableDesigner.pendingImportedDraft = imported.draft;
         state.tableDesigner.selectedTableName = null;
@@ -3169,6 +3387,10 @@ export function queueTableDesignerCsvImport(fileName, csvText) {
         emitChange();
         return imported;
     } catch (error) {
+        if (options.throwOnError) {
+            throw error;
+        }
+
         pushToast(error?.message || 'CSV import failed.', 'alert');
         return null;
     }
@@ -3627,6 +3849,26 @@ export function openDataRowByIdentity(tableName, identity) {
     return true;
 }
 
+export function preserveCurrentDataRowSelectionForReload() {
+    const tableName = state.dataBrowser.selectedTable ?? state.dataBrowser.table?.name ?? '';
+    const row = getSelectedDataBrowserRow();
+    const rowIndex =
+        typeof state.dataBrowser.selectedRowIndex === 'number' ? state.dataBrowser.selectedRowIndex : null;
+
+    if (!tableName || !row) {
+        return false;
+    }
+
+    state.dataBrowser.pendingOpenRow = {
+        tableName,
+        identity: row.__identity ?? null,
+        rowIndex,
+    };
+    clearDataBrowserRowSelectionState();
+    state.dataBrowser.saveError = null;
+    return true;
+}
+
 export function selectEditorRow(index) {
     const numericIndex = Number(index);
 
@@ -4132,25 +4374,138 @@ export async function submitDeleteQueryHistoryConfirmation() {
     return deleted;
 }
 
-export async function exportCurrentQueryCsv() {
+function beginCurrentQueryExport() {
     state.editor.exportLoading = true;
+    if (state.modal?.kind === 'query-export') {
+        state.modal.submitting = true;
+        state.modal.error = null;
+    }
     emitChange();
+}
+
+function reportCurrentQueryExportError(error) {
+    if (state.modal?.kind === 'query-export') {
+        withModalError(error);
+        return;
+    }
+
+    state.editor.error = normalizeError(error);
+    emitChange();
+}
+
+function finishCurrentQueryExport() {
+    state.editor.exportLoading = false;
+    if (state.modal?.kind === 'query-export') {
+        state.modal.submitting = false;
+    }
+    emitChange();
+}
+
+export async function exportCurrentQueryFormat(format = 'csv', filename = '') {
+    const normalizedFormat = String(format ?? 'csv').toLowerCase();
+    const label = TEXT_EXPORT_FORMAT_LABELS[normalizedFormat] ?? TEXT_EXPORT_FORMAT_LABELS.csv;
+    const exportFilename = getCurrentQueryExportFilename(normalizedFormat, filename || state.modal?.filename);
+
+    if (state.modal?.kind === 'query-export') {
+        state.modal.filename = exportFilename;
+    }
+
+    beginCurrentQueryExport();
 
     try {
-        await api.downloadQueryCsv(state.editor.sqlText);
-        pushToast('Query export started.', 'success');
+        await api.downloadQueryExport(state.editor.sqlText, normalizedFormat, { filename: exportFilename });
+        closeModalInternal();
+        pushToast(`${label} export started.`, 'success');
         return true;
     } catch (error) {
-        state.editor.error = normalizeError(error);
-        emitChange();
+        reportCurrentQueryExportError(error);
         return false;
     } finally {
-        state.editor.exportLoading = false;
+        finishCurrentQueryExport();
+    }
+}
+
+export async function duplicateCurrentQueryAsTable(filename = '') {
+    const exportFilename = getCurrentQueryExportFilename('csv', filename || state.modal?.filename);
+
+    if (state.modal?.kind === 'query-export') {
+        state.modal.filename = exportFilename;
+    }
+
+    beginCurrentQueryExport();
+
+    try {
+        const response = await api.getQueryExport(state.editor.sqlText, 'csv');
+        const exportData = response?.data ?? {};
+        const imported = queueTableDesignerCsvImport(
+            exportFilename || getCurrentQueryExportFilename('csv', exportData.filename),
+            exportData.content || '',
+            { throwOnError: true },
+        );
+
+        closeModalInternal();
+        pushToast(
+            `Table draft created from ${imported.importedRowCount} row${imported.importedRowCount === 1 ? '' : 's'}.`,
+            'success',
+        );
+        return imported;
+    } catch (error) {
+        reportCurrentQueryExportError(error);
+        return null;
+    } finally {
+        finishCurrentQueryExport();
+    }
+}
+
+export async function exportCurrentQueryCsv() {
+    try {
+        return await exportCurrentQueryFormat('csv');
+    } catch (error) {
+        state.editor.error = normalizeError(error);
         emitChange();
+        return false;
     }
 }
 
-export async function exportCurrentDataTableCsv() {
+function getCurrentDataTableExportOptions(format = 'csv') {
+    return {
+        sortColumn: state.dataBrowser.sortColumn,
+        sortDirection: state.dataBrowser.sortDirection,
+        filterColumn: state.dataBrowser.searchColumn,
+        filterOperator: state.dataBrowser.filterOperator,
+        filterValue: state.dataBrowser.searchQuery,
+        format,
+    };
+}
+
+function beginCurrentDataTableExport() {
+    state.dataBrowser.exportLoading = true;
+    if (state.modal?.kind === 'data-export') {
+        state.modal.submitting = true;
+        state.modal.error = null;
+    }
+    emitChange();
+}
+
+function reportCurrentDataTableExportError(error) {
+    if (state.modal?.kind === 'data-export') {
+        withModalError(error);
+        return;
+    }
+
+    state.dataBrowser.error = normalizeError(error);
+    emitChange();
+}
+
+function finishCurrentDataTableExport() {
+    state.dataBrowser.exportLoading = false;
+    if (state.modal?.kind === 'data-export') {
+        state.modal.submitting = false;
+    }
+    emitChange();
+}
+
+export async function exportCurrentDataTableFormat(format = 'csv', filename = '') {
     const tableName = state.dataBrowser.selectedTable;
 
     if (!tableName) {
@@ -4158,26 +4513,82 @@ export async function exportCurrentDataTableCsv() {
         return false;
     }
 
-    state.dataBrowser.exportLoading = true;
-    emitChange();
+    const normalizedFormat = String(format ?? 'csv').toLowerCase();
+    const label = TEXT_EXPORT_FORMAT_LABELS[normalizedFormat] ?? TEXT_EXPORT_FORMAT_LABELS.csv;
+    const exportFilename = getCurrentDataTableExportFilename(normalizedFormat, filename || state.modal?.filename);
+
+    if (state.modal?.kind === 'data-export') {
+        state.modal.filename = exportFilename;
+    }
+
+    beginCurrentDataTableExport();
 
     try {
-        await api.downloadTableCsv(tableName, {
-            sortColumn: state.dataBrowser.sortColumn,
-            sortDirection: state.dataBrowser.sortDirection,
+        await api.downloadTableExport(tableName, {
+            ...getCurrentDataTableExportOptions(normalizedFormat),
+            filename: exportFilename,
         });
-        pushToast(`CSV export started for ${tableName}.`, 'success');
+        closeModalInternal();
+        pushToast(`${label} export started for ${tableName}.`, 'success');
         return true;
     } catch (error) {
-        state.dataBrowser.error = normalizeError(error);
-        emitChange();
+        reportCurrentDataTableExportError(error);
         return false;
     } finally {
-        state.dataBrowser.exportLoading = false;
-        emitChange();
+        finishCurrentDataTableExport();
+    }
+}
+
+export async function duplicateCurrentDataTableAsTable(filename = '') {
+    const tableName = state.dataBrowser.selectedTable;
+
+    if (!tableName) {
+        pushToast('No table selected for export.', 'alert');
+        return null;
+    }
+
+    const exportFilename = getCurrentDataTableExportFilename('csv', filename || state.modal?.filename);
+
+    if (state.modal?.kind === 'data-export') {
+        state.modal.filename = exportFilename;
+    }
+
+    beginCurrentDataTableExport();
+
+    try {
+        const response = await api.getTableExport(tableName, getCurrentDataTableExportOptions('csv'));
+        const exportData = response?.data ?? {};
+        const imported = queueTableDesignerCsvImport(
+            exportFilename || getCurrentDataTableExportFilename('csv', exportData.filename),
+            exportData.content || '',
+            {
+                throwOnError: true,
+                context: {
+                    catalogTables: state.tableDesigner.tables?.length
+                        ? state.tableDesigner.tables
+                        : state.dataBrowser.tables,
+                },
+            },
+        );
+
+        closeModalInternal();
+        pushToast(
+            `Table draft created from ${imported.importedRowCount} row${imported.importedRowCount === 1 ? '' : 's'}.`,
+            'success',
+        );
+        return imported;
+    } catch (error) {
+        reportCurrentDataTableExportError(error);
+        return null;
+    } finally {
+        finishCurrentDataTableExport();
     }
 }
 
+export async function exportCurrentDataTableCsv() {
+    return exportCurrentDataTableFormat('csv');
+}
+
 export function sortEditorResultsByColumn(columnName) {
     const normalizedColumn = String(columnName ?? '').trim();
     const result = state.editor.result;