sqlite-hub 0.16.0 → 0.17.2

package/frontend/js/store.js

@@ -24,6 +24,7 @@ import {
     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 = {
@@ -50,6 +51,8 @@ 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;
@@ -73,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 {
@@ -252,6 +256,7 @@ const state = {
         loading: false,
         error: null,
         appVersion: null,
+        sqliteVersion: null,
     },
     overview: {
         data: null,
@@ -333,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,
@@ -538,6 +559,7 @@ function requiresActiveDatabase(routeName) {
         'editor',
         'editorResults',
         'charts',
+        'documents',
         'structure',
         'tableDesigner',
         'mediaTaggingSetup',
@@ -915,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()
@@ -1043,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() {
@@ -1126,6 +1218,9 @@ function setMissingDatabaseState() {
     resetChartsState();
     state.charts.error = error;
 
+    resetDocumentsState();
+    state.documents.error = error;
+
     resetQueryHistoryState({ preserveSearch: false });
 }
 
@@ -1171,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 = [];
     }
@@ -1210,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 {
@@ -1497,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;
@@ -2082,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;
@@ -2148,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();
@@ -2381,6 +2554,7 @@ export function openCopyColumnModal({ scope = 'editor', columnName = '', mode =
         separator: preferences.separator,
         wrapper: preferences.wrapper,
         lineBreaks: preferences.lineBreaks,
+        editedText: null,
         error: null,
         submitting: false,
     };
@@ -2425,6 +2599,14 @@ export function updateCopyColumnModalFormatField(field, value) {
     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;
@@ -2445,6 +2627,445 @@ export function setCopyColumnModalError(error) {
     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);
 
@@ -2611,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();
 }
@@ -2849,6 +3490,16 @@ export async function submitCreateConnection(payload) {
     }
 }
 
+export async function chooseCreateDatabasePath() {
+    try {
+        const response = await api.chooseCreateDatabasePath();
+        return response.data?.path ?? null;
+    } catch (error) {
+        pushToast(normalizeError(error).message || 'Native file dialog could not be opened.', 'alert');
+        return null;
+    }
+}
+
 export async function submitImportSql(payload) {
     startModalSubmission();
 
@@ -4662,11 +5313,13 @@ export function getQueryMessages(snapshot = state) {
 
     return [
         ...snapshot.editor.result.statements.map(statement => ({
-            tone: statement.kind === 'resultSet' ? 'success' : inferStatusTone(statement.keyword),
+            tone: statement.kind === 'resultSet' && statement.truncated ? 'warning' : statement.kind === 'resultSet' ? 'success' : inferStatusTone(statement.keyword),
             label: `${statement.keyword} #${statement.index + 1}`,
             value:
                 statement.kind === 'resultSet'
-                    ? `${statement.rowCount} row(s) returned.`
+                    ? statement.truncated
+                        ? `Showing the first ${statement.rowCount} row(s); the result was limited to ${statement.rowLimit}.`
+                        : `${statement.rowCount} row(s) returned.`
                     : `${statement.changes} row(s) affected.`,
         })),
         ...queryMessages,