sqlite-hub 0.12.0 → 0.17.0

package/frontend/js/store.js

@@ -7,6 +7,7 @@ import {
     hydrateTableDesignerDraft,
     removeTableDesignerColumn,
     updateTableDesignerColumnField,
+    updateTableDesignerConstraintField,
     updateTableDesignerDraftField,
 } from './utils/tableDesigner.js';
 import {
@@ -22,6 +23,8 @@ import {
     MEDIA_TAGGING_DEFAULT_MAPPING_TABLE,
     MEDIA_TAGGING_DEFAULT_TAG_TABLE,
 } from './lib/mediaTaggingDefaults.js';
+import { buildTextExportFilename } from './utils/exportFilenames.js';
+import { toggleMarkdownTodoLine } from './utils/markdownDocuments.js';
 
 const listeners = new Set();
 const DEFAULT_SETTINGS = {
@@ -35,6 +38,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',
@@ -45,11 +51,14 @@ const UI_PREFERENCE_STORAGE_KEYS = {
     chartsHistoryVisible: 'sqlite_hub_charts_history_visible',
     chartsResultsVisible: 'sqlite_hub_charts_results_visible',
     tableDesignerSqlPreviewVisible: 'sqlite_hub_table_designer_sql_preview_visible',
+    documentsEditorVisible: 'sqlite_hub_documents_editor_visible',
+    documentsPreviewVisible: 'sqlite_hub_documents_preview_visible',
 };
 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',
@@ -67,6 +76,7 @@ let queryHistorySearchTimer = null;
 let chartsLoadVersion = 0;
 let chartsDetailLoadVersion = 0;
 let mediaTaggingPreviewVersion = 0;
+let documentsLoadVersion = 0;
 
 function readStoredDataPageSize(fallback = DEFAULT_DATA_PAGE_SIZE) {
     try {
@@ -84,6 +94,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 +165,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);
@@ -197,6 +256,7 @@ const state = {
         loading: false,
         error: null,
         appVersion: null,
+        sqliteVersion: null,
     },
     overview: {
         data: null,
@@ -278,6 +338,22 @@ const state = {
         resultLoading: false,
         resultError: null,
     },
+    documents: {
+        items: [],
+        selectedId: null,
+        selected: null,
+        draftFilename: '',
+        draftContent: '',
+        dirty: false,
+        editorVisible: readStoredBoolean(UI_PREFERENCE_STORAGE_KEYS.documentsEditorVisible, true),
+        previewVisible: readStoredBoolean(UI_PREFERENCE_STORAGE_KEYS.documentsPreviewVisible, true),
+        loading: false,
+        detailLoading: false,
+        saving: false,
+        deleting: false,
+        error: null,
+        saveError: null,
+    },
     tableDesigner: {
         tables: [],
         selectedTableName: null,
@@ -483,6 +559,7 @@ function requiresActiveDatabase(routeName) {
         'editor',
         'editorResults',
         'charts',
+        'documents',
         'structure',
         'tableDesigner',
         'mediaTaggingSetup',
@@ -860,6 +937,74 @@ function resetChartsState() {
     state.charts.resultError = null;
 }
 
+function resetDocumentsState() {
+    documentsLoadVersion += 1;
+    state.documents.items = [];
+    state.documents.selectedId = null;
+    state.documents.selected = null;
+    state.documents.draftFilename = '';
+    state.documents.draftContent = '';
+    state.documents.dirty = false;
+    state.documents.loading = false;
+    state.documents.detailLoading = false;
+    state.documents.saving = false;
+    state.documents.deleting = false;
+    state.documents.error = null;
+    state.documents.saveError = null;
+}
+
+function applyCurrentDocument(document) {
+    state.documents.selectedId = document?.id ?? null;
+    state.documents.selected = document ?? null;
+    state.documents.draftFilename = document?.filename ?? '';
+    state.documents.draftContent = document?.content ?? '';
+    state.documents.dirty = false;
+    state.documents.saveError = null;
+}
+
+function upsertDocumentSummary(document) {
+    if (!document?.id) {
+        return;
+    }
+
+    const summary = {
+        id: document.id,
+        databaseKey: document.databaseKey,
+        title: document.title,
+        filename: document.filename,
+        contentLength: document.contentLength,
+        createdAt: document.createdAt,
+        updatedAt: document.updatedAt,
+    };
+    const existingIndex = state.documents.items.findIndex(item => item.id === document.id);
+
+    if (existingIndex >= 0) {
+        state.documents.items.splice(existingIndex, 1, summary);
+    } else {
+        state.documents.items.unshift(summary);
+    }
+
+    state.documents.items.sort((left, right) => {
+        const leftTime = Date.parse(left.updatedAt ?? '') || 0;
+        const rightTime = Date.parse(right.updatedAt ?? '') || 0;
+        return rightTime - leftTime || String(left.id).localeCompare(String(right.id));
+    });
+}
+
+function resolveDocumentSelection(route) {
+    const requestedId = String(route.params?.documentId ?? '').trim();
+
+    if (requestedId && state.documents.items.some(item => String(item.id) === requestedId)) {
+        return requestedId;
+    }
+
+    if (state.documents.selectedId && state.documents.items.some(item => item.id === state.documents.selectedId)) {
+        return state.documents.selectedId;
+    }
+
+    return state.documents.items[0]?.id ?? null;
+}
+
 function normalizeChartsHeightPreset(value) {
     const normalizedValue = String(value ?? '')
         .trim()
@@ -988,6 +1133,8 @@ function clearRouteSlices() {
     state.tableDesigner.saveError = null;
     state.structure.error = null;
     state.mediaTagging.error = null;
+    state.documents.error = null;
+    state.documents.saveError = null;
 }
 
 function setMissingDatabaseState() {
@@ -1071,6 +1218,9 @@ function setMissingDatabaseState() {
     resetChartsState();
     state.charts.error = error;
 
+    resetDocumentsState();
+    state.documents.error = error;
+
     resetQueryHistoryState({ preserveSearch: false });
 }
 
@@ -1116,6 +1266,10 @@ function syncRouteContext() {
         state.tableDesigner.saveError = null;
     }
 
+    if (route.name !== 'documents') {
+        state.documents.saveError = null;
+    }
+
     if (route.name !== 'mediaTaggingSetup' && route.name !== 'mediaTaggingQueue') {
         state.mediaTagging.selectedTagKeys = [];
     }
@@ -1155,6 +1309,7 @@ async function refreshSettingsState() {
             ...(response.data ?? {}),
         };
         state.settings.appVersion = response.metadata?.appVersion ?? null;
+        state.settings.sqliteVersion = response.metadata?.sqliteVersion ?? null;
     } catch (error) {
         state.settings.error = normalizeError(error);
     } finally {
@@ -1442,6 +1597,75 @@ async function loadCharts(version, route, options = {}) {
     await loadChartsDetail(resolveLoadableChartsHistoryId(route));
 }
 
+async function loadDocumentDetail(version, documentId) {
+    if (!documentId) {
+        applyCurrentDocument(null);
+        return;
+    }
+
+    state.documents.detailLoading = true;
+    state.documents.saveError = null;
+    emitChange();
+
+    try {
+        const response = await api.getDocument(documentId);
+
+        if (version !== routeLoadVersion) {
+            return;
+        }
+
+        const document = response.data ?? null;
+        applyCurrentDocument(document);
+        upsertDocumentSummary(document);
+    } catch (error) {
+        if (version !== routeLoadVersion) {
+            return;
+        }
+
+        applyCurrentDocument(null);
+        state.documents.error = normalizeError(error);
+    } finally {
+        if (version === routeLoadVersion) {
+            state.documents.detailLoading = false;
+            emitChange();
+        }
+    }
+}
+
+async function loadDocuments(version, route) {
+    const requestVersion = ++documentsLoadVersion;
+
+    state.documents.loading = true;
+    state.documents.error = null;
+    emitChange();
+
+    try {
+        const response = await api.getDocuments();
+
+        if (version !== routeLoadVersion || requestVersion !== documentsLoadVersion) {
+            return;
+        }
+
+        state.documents.items = response.data?.items ?? [];
+        state.documents.error = null;
+
+        await loadDocumentDetail(version, resolveDocumentSelection(route));
+    } catch (error) {
+        if (version !== routeLoadVersion || requestVersion !== documentsLoadVersion) {
+            return;
+        }
+
+        state.documents.items = [];
+        applyCurrentDocument(null);
+        state.documents.error = normalizeError(error);
+    } finally {
+        if (version === routeLoadVersion && requestVersion === documentsLoadVersion) {
+            state.documents.loading = false;
+            emitChange();
+        }
+    }
+}
+
 async function loadOverview(version) {
     state.overview.loading = true;
     state.overview.error = null;
@@ -1480,6 +1704,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) {
@@ -2017,6 +2251,7 @@ function invalidateDatabaseCaches(options = {}) {
     state.structure.detail = null;
     state.structure.tablesVisible = readStoredBoolean(UI_PREFERENCE_STORAGE_KEYS.structureTablesVisible, true);
     state.structure.tableSearchQuery = '';
+    resetDocumentsState();
     state.mediaTagging.loading = false;
     state.mediaTagging.previewLoading = false;
     state.mediaTagging.saving = false;
@@ -2083,6 +2318,9 @@ async function loadRouteData(route, options = {}) {
         case 'charts':
             await loadCharts(version, route, options);
             return;
+        case 'documents':
+            await loadDocuments(version, route);
+            return;
         case 'editor':
         case 'editorResults':
             await refreshQueryHistoryState();
@@ -2255,11 +2493,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 +2511,7 @@ export function openQueryExportModal() {
 
     state.modal = {
         kind: 'query-export',
+        filename: getCurrentQueryExportFilename('csv'),
         error: null,
         submitting: false,
     };
@@ -2286,12 +2526,546 @@ 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,
+        editedText: null,
+        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 setCopyColumnModalEditedText(text) {
+    if (state.modal?.kind !== 'copy-column') {
+        return;
+    }
+
+    state.modal.editedText = String(text ?? '');
+}
+
+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 updateCurrentDocumentDraftField(field, value) {
+    if (state.route.name !== 'documents') {
+        return;
+    }
+
+    const normalizedField = String(field ?? '').trim();
+
+    if (normalizedField === 'filename') {
+        state.documents.draftFilename = String(value ?? '');
+    } else if (normalizedField === 'content') {
+        state.documents.draftContent = String(value ?? '');
+    } else {
+        return;
+    }
+
+    state.documents.dirty = true;
+    state.documents.saveError = null;
+    emitChange();
+}
+
+export function setDocumentsPaneVisibility(pane, visible) {
+    const normalizedPane = String(pane ?? '').trim();
+    const nextVisible = Boolean(visible);
+
+    if (normalizedPane !== 'editor' && normalizedPane !== 'preview') {
+        return;
+    }
+
+    if (normalizedPane === 'editor') {
+        state.documents.editorVisible = nextVisible;
+
+        if (!state.documents.editorVisible && !state.documents.previewVisible) {
+            state.documents.previewVisible = true;
+        }
+    } else {
+        state.documents.previewVisible = nextVisible;
+
+        if (!state.documents.editorVisible && !state.documents.previewVisible) {
+            state.documents.editorVisible = true;
+        }
+    }
+
+    storeBoolean(UI_PREFERENCE_STORAGE_KEYS.documentsEditorVisible, state.documents.editorVisible);
+    storeBoolean(UI_PREFERENCE_STORAGE_KEYS.documentsPreviewVisible, state.documents.previewVisible);
+    emitChange();
+}
+
+export function toggleDocumentsPane(pane) {
+    const normalizedPane = String(pane ?? '').trim();
+
+    if (normalizedPane === 'editor') {
+        setDocumentsPaneVisibility('editor', !state.documents.editorVisible);
+    } else if (normalizedPane === 'preview') {
+        setDocumentsPaneVisibility('preview', !state.documents.previewVisible);
+    }
+}
+
+function normalizeDocumentInsertionRange(range = null) {
+    const contentLength = String(state.documents.draftContent ?? '').length;
+    const start = Number(range?.start);
+    const end = Number(range?.end);
+    const normalizedStart = Number.isInteger(start) ? Math.max(0, Math.min(contentLength, start)) : contentLength;
+    const normalizedEnd = Number.isInteger(end) ? Math.max(normalizedStart, Math.min(contentLength, end)) : normalizedStart;
+
+    return {
+        start: normalizedStart,
+        end: normalizedEnd,
+    };
+}
+
+function buildDocumentMarkdownInsertion(currentContent, insertion, range = null) {
+    const content = String(currentContent ?? '');
+    const text = String(insertion ?? '').trim();
+
+    if (!text) {
+        return content;
+    }
+
+    const normalizedRange = normalizeDocumentInsertionRange(range);
+    const before = content.slice(0, normalizedRange.start);
+    const after = content.slice(normalizedRange.end);
+    const prefix = before && !before.endsWith('\n\n') ? (before.endsWith('\n') ? '\n' : '\n\n') : '';
+    const suffix = after && !after.startsWith('\n\n') ? (after.startsWith('\n') ? '\n' : '\n\n') : '';
+
+    return `${before}${prefix}${text}${suffix}${after}`;
+}
+
+function insertMarkdownIntoCurrentDocumentDraft(markdown, range = null) {
+    if (!state.documents.selectedId) {
+        return false;
+    }
+
+    const nextContent = buildDocumentMarkdownInsertion(state.documents.draftContent, markdown, range);
+
+    if (nextContent === state.documents.draftContent) {
+        return false;
+    }
+
+    state.documents.draftContent = nextContent;
+    state.documents.dirty = true;
+    state.documents.saveError = null;
+    emitChange();
+    return true;
+}
+
+function getDocumentInsertQueryTitle(query) {
+    return query?.displayTitle || query?.title || query?.previewSql || query?.rawSql || 'Saved query';
+}
+
+async function openDocumentInsertModal(kind, insertionRange = null) {
+    if (!state.documents.selectedId) {
+        pushToast('Select a document before inserting Markdown.', 'alert');
+        return;
+    }
+
+    state.modal = {
+        kind,
+        documentId: state.documents.selectedId,
+        insertionRange: normalizeDocumentInsertionRange(insertionRange),
+        queries: [],
+        selectedHistoryId: '',
+        loading: true,
+        error: null,
+        submitting: false,
+    };
+    emitChange();
+
+    try {
+        const response = await api.getQueryHistory({
+            tab: 'saved',
+            onlySaved: true,
+            limit: 100,
+        });
+        const loadedQueries = response.data?.items ?? [];
+        const queries =
+            kind === 'document-insert-note'
+                ? loadedQueries.filter(query => String(query.notes ?? '').trim())
+                : loadedQueries;
+
+        if (state.modal?.kind !== kind) {
+            return;
+        }
+
+        state.modal.queries = queries;
+        state.modal.selectedHistoryId = String(queries[0]?.id ?? '');
+        state.modal.loading = false;
+        state.modal.error = null;
+        emitChange();
+    } catch (error) {
+        if (state.modal?.kind !== kind) {
+            return;
+        }
+
+        state.modal.loading = false;
+        state.modal.error = normalizeError(error);
+        emitChange();
+    }
+}
+
+export function updateDocumentInsertQuerySelection(historyId) {
+    if (state.modal?.kind !== 'document-insert-table' && state.modal?.kind !== 'document-insert-note') {
+        return;
+    }
+
+    state.modal.selectedHistoryId = String(historyId ?? '');
+    state.modal.error = null;
+    emitChange();
+}
+
+function getSelectedDocumentInsertQuery(modal) {
+    const selectedHistoryId = String(modal?.selectedHistoryId ?? '');
+
+    return (modal?.queries ?? []).find(query => String(query.id) === selectedHistoryId) ?? null;
+}
+
+function setDocumentInsertModalError(message, code = 'DOCUMENT_INSERT_UNAVAILABLE') {
+    if (!state.modal) {
+        return;
+    }
+
+    state.modal.error = { code, message };
+    state.modal.submitting = false;
+    emitChange();
+}
+
+function canSubmitDocumentInsertModal(modal, kind) {
+    if (modal?.kind !== kind) {
+        return false;
+    }
+
+    if (String(modal.documentId ?? '') !== String(state.documents.selectedId ?? '')) {
+        setDocumentInsertModalError('The selected document changed while the dialog was open.');
+        return false;
+    }
+
+    return true;
+}
+
+export async function openDocumentInsertTableModal(insertionRange = null) {
+    await openDocumentInsertModal('document-insert-table', insertionRange);
+}
+
+export async function openDocumentInsertNoteModal(insertionRange = null) {
+    await openDocumentInsertModal('document-insert-note', insertionRange);
+}
+
+export async function submitDocumentInsertTable() {
+    const modal = state.modal;
+
+    if (!canSubmitDocumentInsertModal(modal, 'document-insert-table')) {
+        return false;
+    }
+
+    const query = getSelectedDocumentInsertQuery(modal);
+
+    if (!query) {
+        setDocumentInsertModalError('Select a saved query before inserting a table.');
+        return false;
+    }
+
+    startModalSubmission();
+
+    try {
+        const response = await api.getQueryExport(query.rawSql, 'md');
+        const markdownTable = String(response.data?.content ?? '').trim();
+
+        if (!markdownTable) {
+            throw new Error('The selected query returned no Markdown table content.');
+        }
+
+        const inserted = insertMarkdownIntoCurrentDocumentDraft(markdownTable, modal.insertionRange);
+
+        closeModalInternal();
+        if (inserted) {
+            pushToast(`Inserted table from "${getDocumentInsertQueryTitle(query)}".`, 'success');
+        }
+        return inserted;
+    } catch (error) {
+        withModalError(error);
+        return false;
+    }
+}
+
+export function submitDocumentInsertNote() {
+    const modal = state.modal;
+
+    if (!canSubmitDocumentInsertModal(modal, 'document-insert-note')) {
+        return false;
+    }
+
+    const query = getSelectedDocumentInsertQuery(modal);
+    const note = String(query?.notes ?? '').trim();
+
+    if (!query || !note) {
+        setDocumentInsertModalError('Select a saved query with notes before inserting.');
+        return false;
+    }
+
+    startModalSubmission();
+    const inserted = insertMarkdownIntoCurrentDocumentDraft(note, modal.insertionRange);
+
+    closeModalInternal();
+    if (inserted) {
+        pushToast(`Inserted note from "${getDocumentInsertQueryTitle(query)}".`, 'success');
+    }
+    return inserted;
+}
+
+export async function createDocument(options = {}) {
+    state.documents.saving = true;
+    state.documents.saveError = null;
+    emitChange();
+
+    try {
+        const response = await api.createDocument({
+            title: options.title,
+            filename: options.filename,
+            content: options.content,
+        });
+        const document = response.data ?? null;
+
+        if (document) {
+            upsertDocumentSummary(document);
+            applyCurrentDocument(document);
+        }
+
+        if (options.toast !== false) {
+            pushToast(`Document "${document?.filename ?? 'Untitled.md'}" created.`, 'success');
+        }
+
+        return document;
+    } catch (error) {
+        state.documents.saveError = normalizeError(error);
+        if (options.toast !== false) {
+            pushToast(state.documents.saveError.message || 'Document could not be created.', 'alert');
+        }
+        return null;
+    } finally {
+        state.documents.saving = false;
+        emitChange();
+    }
+}
+
+export async function saveCurrentDocument(options = {}) {
+    const documentId = state.documents.selectedId;
+
+    if (!documentId) {
+        return null;
+    }
+
+    const submittedFilename = state.documents.draftFilename;
+    const submittedContent = state.documents.draftContent;
+
+    state.documents.saving = true;
+    state.documents.saveError = null;
+    emitChange();
+
+    try {
+        const response = await api.updateDocument(documentId, {
+            filename: submittedFilename,
+            content: submittedContent,
+        });
+        const document = response.data ?? null;
+
+        if (document) {
+            const draftUnchanged =
+                String(state.documents.selectedId ?? '') === String(documentId) &&
+                state.documents.draftFilename === submittedFilename &&
+                state.documents.draftContent === submittedContent;
+
+            upsertDocumentSummary(document);
+            if (draftUnchanged) {
+                applyCurrentDocument(document);
+            }
+        }
+
+        if (options.toast !== false) {
+            pushToast(`Document "${document?.filename ?? 'document'}" saved.`, 'success');
+        }
+
+        return document;
+    } catch (error) {
+        state.documents.saveError = normalizeError(error);
+        if (options.toast !== false) {
+            pushToast(state.documents.saveError.message || 'Document could not be saved.', 'alert');
+        }
+        return null;
+    } finally {
+        state.documents.saving = false;
+        emitChange();
+    }
+}
+
+export async function deleteCurrentDocument(options = {}) {
+    const documentId = options.documentId ?? state.documents.selectedId;
+    const reportErrorToModal = Boolean(options.reportErrorToModal);
+
+    if (!documentId) {
+        return { deleted: false, nextDocumentId: null };
+    }
+
+    const deletedIndex = state.documents.items.findIndex(item => item.id === documentId);
+    const isSelectedDocument = String(state.documents.selectedId ?? '') === String(documentId);
+
+    state.documents.deleting = true;
+    state.documents.saveError = null;
+    emitChange();
+
+    try {
+        await api.deleteDocument(documentId);
+        state.documents.items = state.documents.items.filter(item => item.id !== documentId);
+        const nextDocument = state.documents.items[Math.max(0, Math.min(deletedIndex, state.documents.items.length - 1))] ?? null;
+        if (isSelectedDocument) {
+            applyCurrentDocument(null);
+        }
+        pushToast('Document deleted.', 'success');
+        return { deleted: true, nextDocumentId: nextDocument?.id ?? null };
+    } catch (error) {
+        state.documents.saveError = normalizeError(error);
+        if (reportErrorToModal) {
+            withModalError(error);
+        } else {
+            pushToast(state.documents.saveError.message || 'Document could not be deleted.', 'alert');
+        }
+        return { deleted: false, nextDocumentId: null };
+    } finally {
+        state.documents.deleting = false;
+        emitChange();
+    }
+}
+
+export async function toggleCurrentDocumentTodo(lineIndex) {
+    if (!state.documents.selectedId) {
+        return null;
+    }
+
+    const nextContent = toggleMarkdownTodoLine(state.documents.draftContent, lineIndex);
+
+    if (nextContent === state.documents.draftContent) {
+        return state.documents.selected;
+    }
+
+    state.documents.draftContent = nextContent;
+    state.documents.dirty = true;
+    state.documents.saveError = null;
+    emitChange();
+
+    return saveCurrentDocument({ toast: false });
+}
+
+export async function createDocumentFromMarkdownExport({ filename, content, title } = {}) {
+    return createDocument({
+        title,
+        filename,
+        content,
+        toast: false,
+    });
+}
+
+export async function submitDeleteDocumentConfirmation() {
+    const modal = state.modal;
+
+    if (modal?.kind !== 'delete-document') {
+        return { deleted: false, nextDocumentId: null };
+    }
+
+    startModalSubmission();
+    const result = await deleteCurrentDocument({
+        documentId: modal.documentId,
+        reportErrorToModal: true,
+    });
+
+    if (result.deleted) {
+        closeModalInternal();
+    }
+
+    return result;
+}
+
 export function openEditConnectionModal(id) {
     const connection = state.connections.recent.find(entry => entry.id === id);
 
@@ -2458,6 +3232,26 @@ export function openDeleteQueryHistoryModal(historyId) {
     emitChange();
 }
 
+export function openDeleteDocumentModal() {
+    const documentId = state.documents.selectedId;
+    const document = state.documents.selected;
+
+    if (!documentId || !document) {
+        pushToast('The selected document could not be loaded.', 'alert');
+        return;
+    }
+
+    state.modal = {
+        kind: 'delete-document',
+        documentId,
+        filename: document.filename,
+        contentLength: document.contentLength ?? String(document.content ?? '').length,
+        error: null,
+        submitting: false,
+    };
+    emitChange();
+}
+
 export function closeModal() {
     closeModalInternal();
 }
@@ -3182,6 +3976,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 +4490,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 +5042,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 +5066,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 +5146,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 +5156,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 +5180,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 +5188,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,