sqlite-hub 0.12.0 → 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,7 @@ 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',
@@ -84,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);
@@ -127,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);
@@ -1480,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) {
@@ -2255,11 +2320,12 @@ 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();
 }
@@ -2272,6 +2338,7 @@ export function openQueryExportModal() {
 
     state.modal = {
         kind: 'query-export',
+        filename: getCurrentQueryExportFilename('csv'),
         error: null,
         submitting: false,
     };
@@ -2286,12 +2353,98 @@ export function openDataExportModal() {
 
     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);
 
@@ -3182,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;
@@ -3676,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);
 
@@ -4208,14 +4401,19 @@ function finishCurrentQueryExport() {
     emitChange();
 }
 
-export async function exportCurrentQueryFormat(format = 'csv') {
+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.downloadQueryExport(state.editor.sqlText, normalizedFormat);
+        await api.downloadQueryExport(state.editor.sqlText, normalizedFormat, { filename: exportFilename });
         closeModalInternal();
         pushToast(`${label} export started.`, 'success');
         return true;
@@ -4227,14 +4425,20 @@ export async function exportCurrentQueryFormat(format = 'csv') {
     }
 }
 
-export async function duplicateCurrentQueryAsTable() {
+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(
-            exportData.filename || 'query-results.csv',
+            exportFilename || getCurrentQueryExportFilename('csv', exportData.filename),
             exportData.content || '',
             { throwOnError: true },
         );
@@ -4301,7 +4505,7 @@ function finishCurrentDataTableExport() {
     emitChange();
 }
 
-export async function exportCurrentDataTableFormat(format = 'csv') {
+export async function exportCurrentDataTableFormat(format = 'csv', filename = '') {
     const tableName = state.dataBrowser.selectedTable;
 
     if (!tableName) {
@@ -4311,11 +4515,19 @@ export async function exportCurrentDataTableFormat(format = 'csv') {
 
     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.downloadTableExport(tableName, getCurrentDataTableExportOptions(normalizedFormat));
+        await api.downloadTableExport(tableName, {
+            ...getCurrentDataTableExportOptions(normalizedFormat),
+            filename: exportFilename,
+        });
         closeModalInternal();
         pushToast(`${label} export started for ${tableName}.`, 'success');
         return true;
@@ -4327,7 +4539,7 @@ export async function exportCurrentDataTableFormat(format = 'csv') {
     }
 }
 
-export async function duplicateCurrentDataTableAsTable() {
+export async function duplicateCurrentDataTableAsTable(filename = '') {
     const tableName = state.dataBrowser.selectedTable;
 
     if (!tableName) {
@@ -4335,13 +4547,19 @@ export async function duplicateCurrentDataTableAsTable() {
         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(
-            exportData.filename || `${tableName}.csv`,
+            exportFilename || getCurrentDataTableExportFilename('csv', exportData.filename),
             exportData.content || '',
             {
                 throwOnError: true,

package/frontend/js/utils/copyColumnExport.js

@@ -0,0 +1,117 @@
+export const COPY_COLUMN_MODE_VALUES = ["column", "column-with-header", "first-10", "markdown-todo"];
+
+export function normalizeCopyColumnMode(mode) {
+  const normalizedMode = String(mode ?? "").trim();
+  return COPY_COLUMN_MODE_VALUES.includes(normalizedMode) ? normalizedMode : "column";
+}
+
+export function isMarkdownTodoCopyColumnMode(mode) {
+  return normalizeCopyColumnMode(mode) === "markdown-todo";
+}
+
+export function getCopyColumnActionLabel(copyMode) {
+  const normalizedMode = normalizeCopyColumnMode(copyMode);
+
+  if (normalizedMode === "column-with-header") {
+    return "Copy column with header";
+  }
+
+  if (normalizedMode === "first-10") {
+    return "Copy first 10";
+  }
+
+  if (normalizedMode === "markdown-todo") {
+    return "Export as Markdown Todo";
+  }
+
+  return "Copy column";
+}
+
+export function getCopyColumnExportMetadata(copyMode) {
+  return isMarkdownTodoCopyColumnMode(copyMode)
+    ? {
+        extension: "md",
+        label: "Markdown",
+        mimeType: "text/markdown;charset=utf-8",
+        suffix: "markdown-todo",
+      }
+    : {
+        extension: "txt",
+        label: "TXT",
+        mimeType: "text/plain;charset=utf-8",
+        suffix: normalizeCopyColumnMode(copyMode).replaceAll("-", "_"),
+      };
+}
+
+function stringifyCopyColumnValue(value) {
+  return value === null || value === undefined ? "" : String(value);
+}
+
+function formatDelimitedCopyColumnValue(value, wrapper) {
+  const text = stringifyCopyColumnValue(value);
+  const normalizedWrapper = String(wrapper ?? "");
+
+  if (!normalizedWrapper) {
+    return text;
+  }
+
+  return `${normalizedWrapper}${text
+    .split(normalizedWrapper)
+    .join(`${normalizedWrapper}${normalizedWrapper}`)}${normalizedWrapper}`;
+}
+
+function formatMarkdownTodoValue(value) {
+  return stringifyCopyColumnValue(value).replace(/\r\n|\r|\n/g, " ");
+}
+
+function getCopyColumnSourceRows(result, copyMode) {
+  const rows = result?.rows ?? [];
+  return normalizeCopyColumnMode(copyMode) === "first-10" ? rows.slice(0, 10) : rows;
+}
+
+export function buildCopyColumnText({
+  result,
+  columnName,
+  copyMode = "column",
+  separator = ",",
+  wrapper = "",
+} = {}) {
+  const normalizedMode = normalizeCopyColumnMode(copyMode);
+  const sourceRows = getCopyColumnSourceRows(result, normalizedMode);
+  const values = sourceRows.map((row) => row?.[columnName]);
+
+  if (normalizedMode === "markdown-todo") {
+    return {
+      text: values.map((value) => `- [ ] ${formatMarkdownTodoValue(value)}`).join("\n"),
+      valueCount: values.length,
+    };
+  }
+
+  const outputValues = normalizedMode === "column-with-header" ? [columnName, ...values] : values;
+
+  return {
+    text: outputValues.map((value) => formatDelimitedCopyColumnValue(value, wrapper)).join(separator),
+    valueCount: values.length,
+  };
+}
+
+export function buildCopyColumnPreviewText({
+  result,
+  columnName,
+  copyMode = "column",
+  separator = ",",
+  wrapper = "",
+  maxRows = 4,
+} = {}) {
+  const limitedRows = {
+    rows: getCopyColumnSourceRows(result, copyMode).slice(0, Math.max(0, Number(maxRows) || 0)),
+  };
+
+  return buildCopyColumnText({
+    result: limitedRows,
+    columnName,
+    copyMode: normalizeCopyColumnMode(copyMode) === "first-10" ? "column" : copyMode,
+    separator,
+    wrapper,
+  }).text;
+}

package/frontend/js/utils/exportFilenames.js

@@ -0,0 +1,32 @@
+export const TEXT_EXPORT_EXTENSIONS = {
+  csv: "csv",
+  tsv: "tsv",
+  md: "md",
+};
+
+export function normalizeTextExportFormat(format = "csv") {
+  const normalized = String(format ?? "csv").toLowerCase();
+  return TEXT_EXPORT_EXTENSIONS[normalized] ? normalized : "csv";
+}
+
+function stripKnownTextExportExtension(value = "") {
+  return String(value).replace(/\.(csv|tsv|md)$/i, "");
+}
+
+export function sanitizeExportFilenameBase(value, fallback = "export") {
+  const sanitized = stripKnownTextExportExtension(value)
+    .replace(/[<>:"/\\|?*\u0000-\u001f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/^[. ]+|[. ]+$/g, "");
+
+  return (sanitized || fallback).slice(0, 120);
+}
+
+export function buildTextExportFilename(value, { format = "csv", fallback = "export" } = {}) {
+  const normalizedFormat = normalizeTextExportFormat(format);
+  const extension = TEXT_EXPORT_EXTENSIONS[normalizedFormat];
+  const base = sanitizeExportFilenameBase(value, fallback);
+
+  return `${base}.${extension}`;
+}