sqlite-hub 1.4.0 → 2.0.0

package/frontend/js/store.js

@@ -23,6 +23,11 @@ import { MEDIA_TAGGING_DEFAULT_MAPPING_TABLE, MEDIA_TAGGING_DEFAULT_TAG_TABLE }
 import { buildTextExportFilename } from './utils/exportFilenames.js';
 import { toggleMarkdownTodoLine } from './utils/markdownDocuments.js';
 import { buildRiskySqlBackupContext, detectRiskySqlOperations } from './utils/riskySql.js';
+import {
+    buildSyntheticDataMappings,
+    getDefaultSyntheticOptions,
+    normalizeSyntheticGeneratorType,
+} from './utils/syntheticData.js';
 
 const listeners = new Set();
 const DEFAULT_SETTINGS = {
@@ -59,6 +64,13 @@ const UI_PREFERENCE_STORAGE_KEYS = {
 };
 const QUERY_HISTORY_PAGE_SIZE = 30;
 const QUERY_HISTORY_RUN_LIMIT = 8;
+const LOG_PAGE_SIZE = 80;
+const LOG_KINDS = new Set(['all', 'query', 'access']);
+const LOG_RANGES = new Set(['1h', '24h', '7d', '30d', 'all']);
+const LOG_ACTORS = new Set(['all', 'user', 'cli', 'api', 'mcp']);
+const LOG_STATUSES = new Set(['all', 'success', 'error']);
+const LOG_QUERY_TYPES = new Set(['all', 'select', 'insert', 'update', 'delete', 'pragma', 'create', 'alter', 'drop', 'other']);
+const LOG_DESTRUCTIVE_FILTERS = new Set(['all', 'yes', 'no']);
 const CHART_HEIGHT_PRESETS = new Set(['small', 'medium', 'large']);
 const TYPE_GENERATION_TARGETS = new Set(['typescript', 'rust', 'kotlin', 'swift']);
 const TYPE_GENERATION_NAMING = new Set(['preserve', 'camel', 'pascal', 'snake']);
@@ -258,6 +270,24 @@ function storeQueryHistoryTab(tab) {
     }
 }
 
+function normalizeSetValue(value, allowedValues, fallback) {
+    const normalized = String(value ?? fallback).trim().toLowerCase();
+    return allowedValues.has(normalized) ? normalized : fallback;
+}
+
+function normalizeLogFilters(filters = {}) {
+    return {
+        kind: normalizeSetValue(filters.kind, LOG_KINDS, 'all'),
+        range: normalizeSetValue(filters.range, LOG_RANGES, 'all'),
+        actor: normalizeSetValue(filters.actor, LOG_ACTORS, 'all'),
+        status: normalizeSetValue(filters.status, LOG_STATUSES, 'all'),
+        queryType: normalizeSetValue(filters.queryType, LOG_QUERY_TYPES, 'all'),
+        destructive: normalizeSetValue(filters.destructive, LOG_DESTRUCTIVE_FILTERS, 'all'),
+        searchInput: String(filters.searchInput ?? filters.search ?? ''),
+        search: String(filters.search ?? filters.searchInput ?? '').trim(),
+    };
+}
+
 const state = {
     ready: false,
     route: { name: 'landing', path: '/', params: {} },
@@ -302,12 +332,27 @@ const state = {
         versionCheck: null,
         versionCheckLoading: false,
         versionCheckError: null,
+        mcpStatus: null,
+        mcpStatusLoading: false,
+        mcpStatusError: null,
     },
     overview: {
         data: null,
         loading: false,
         error: null,
     },
+    logs: {
+        items: [],
+        total: 0,
+        limit: LOG_PAGE_SIZE,
+        offset: 0,
+        hasMore: false,
+        loading: false,
+        loadingMore: false,
+        error: null,
+        filters: normalizeLogFilters(),
+        metadata: null,
+    },
     dataBrowser: {
         tables: [],
         selectedTable: null,
@@ -332,6 +377,15 @@ const state = {
         error: null,
         saveError: null,
     },
+    tableAdvisor: {
+        tables: [],
+        selectedTableName: null,
+        result: null,
+        loading: false,
+        analysisLoading: false,
+        error: null,
+        analysisError: null,
+    },
     editor: {
         sqlText: readStoredString(UI_PREFERENCE_STORAGE_KEYS.sqlEditorQueryDraft),
         editorPanelVisible: readStoredBoolean(UI_PREFERENCE_STORAGE_KEYS.sqlEditorEditorVisible, true),
@@ -622,6 +676,7 @@ function requiresActiveDatabase(routeName) {
     return [
         'overview',
         'backups',
+        'logs',
         'data',
         'editor',
         'editorResults',
@@ -629,6 +684,7 @@ function requiresActiveDatabase(routeName) {
         'documents',
         'structure',
         'tableDesigner',
+        'tableAdvisor',
         'mediaTaggingSetup',
         'mediaTaggingQueue',
     ].includes(routeName);
@@ -1290,6 +1346,7 @@ function resolveQueryHistorySql(historyId) {
 
 function clearRouteSlices() {
     state.overview.error = null;
+    state.logs.error = null;
     state.dataBrowser.error = null;
     state.dataBrowser.saveError = null;
     state.charts.error = null;
@@ -1297,6 +1354,8 @@ function clearRouteSlices() {
     state.charts.resultError = null;
     state.tableDesigner.error = null;
     state.tableDesigner.saveError = null;
+    state.tableAdvisor.error = null;
+    state.tableAdvisor.analysisError = null;
     state.structure.error = null;
     state.mediaTagging.error = null;
     state.documents.error = null;
@@ -1310,6 +1369,15 @@ function setMissingDatabaseState() {
     state.overview.data = null;
     state.overview.error = error;
 
+    state.logs.loading = false;
+    state.logs.loadingMore = false;
+    state.logs.items = [];
+    state.logs.total = 0;
+    state.logs.offset = 0;
+    state.logs.hasMore = false;
+    state.logs.error = error;
+    state.logs.metadata = null;
+
     state.dataBrowser.loading = false;
     state.dataBrowser.tableLoading = false;
     state.dataBrowser.tables = [];
@@ -1350,6 +1418,14 @@ function setMissingDatabaseState() {
     state.tableDesigner.error = error;
     state.tableDesigner.saveError = null;
 
+    state.tableAdvisor.loading = false;
+    state.tableAdvisor.analysisLoading = false;
+    state.tableAdvisor.tables = [];
+    state.tableAdvisor.selectedTableName = null;
+    state.tableAdvisor.result = null;
+    state.tableAdvisor.error = error;
+    state.tableAdvisor.analysisError = null;
+
     state.mediaTagging.loading = false;
     state.mediaTagging.previewLoading = false;
     state.mediaTagging.saving = false;
@@ -1495,6 +1571,81 @@ async function refreshSettingsState() {
     }
 }
 
+async function refreshSettingsMcpStatus() {
+    state.settings.mcpStatusLoading = true;
+    state.settings.mcpStatusError = null;
+    emitChange();
+
+    try {
+        const response = await api.getSettingsMcpStatus();
+        state.settings.mcpStatus = response.data ?? null;
+    } catch (error) {
+        state.settings.mcpStatusError = normalizeError(error);
+    } finally {
+        state.settings.mcpStatusLoading = false;
+        emitChange();
+    }
+}
+
+function buildLogRequestOptions({ append = false } = {}) {
+    const filters = normalizeLogFilters(state.logs.filters);
+
+    return {
+        ...filters,
+        search: filters.search,
+        limit: state.logs.limit,
+        offset: append ? state.logs.items.length : 0,
+    };
+}
+
+async function loadLogs(options = {}) {
+    const append = Boolean(options.append);
+
+    if (append && (state.logs.loading || state.logs.loadingMore || !state.logs.hasMore)) {
+        return;
+    }
+
+    if (append) {
+        state.logs.loadingMore = true;
+    } else {
+        state.logs.loading = true;
+        state.logs.offset = 0;
+        state.logs.error = null;
+    }
+
+    emitChange();
+
+    try {
+        const response = await api.getLogs(buildLogRequestOptions({ append }));
+        const data = response.data ?? {};
+        const items = Array.isArray(data.items) ? data.items : [];
+
+        state.logs.items = append ? [...state.logs.items, ...items] : items;
+        state.logs.total = Number(data.total ?? state.logs.items.length);
+        state.logs.limit = Number(data.limit ?? state.logs.limit);
+        state.logs.offset = Number(data.offset ?? 0);
+        state.logs.hasMore = Boolean(data.hasMore);
+        state.logs.metadata = response.metadata ?? data.filters ?? null;
+        state.logs.filters = normalizeLogFilters({
+            ...state.logs.filters,
+            ...(data.filters ?? {}),
+            ...(response.metadata ?? {}),
+        });
+        state.logs.error = null;
+    } catch (error) {
+        state.logs.error = normalizeError(error);
+        if (!append) {
+            state.logs.items = [];
+            state.logs.total = 0;
+            state.logs.hasMore = false;
+        }
+    } finally {
+        state.logs.loading = false;
+        state.logs.loadingMore = false;
+        emitChange();
+    }
+}
+
 async function refreshBackupsState() {
     if (!state.connections.active) {
         state.backups.items = [];
@@ -1542,7 +1693,8 @@ export async function createSettingsApiToken(name) {
 }
 
 export function setSettingsSection(section) {
-    const normalizedSection = section === 'api-tokens' ? 'api-tokens' : 'information';
+    const normalizedSection =
+        section === 'api-tokens' ? 'api-tokens' : section === 'mcp' ? 'mcp' : 'information';
 
     if (state.settings.section === normalizedSection) {
         return;
@@ -1552,7 +1704,51 @@ export function setSettingsSection(section) {
     emitChange();
 }
 
-export async function checkSettingsAppVersion() {
+export async function setLogFilter(field, value) {
+    if (!Object.prototype.hasOwnProperty.call(state.logs.filters, field)) {
+        return;
+    }
+
+    state.logs.filters = normalizeLogFilters({
+        ...state.logs.filters,
+        [field]: value,
+    });
+    state.logs.items = [];
+    state.logs.total = 0;
+    state.logs.hasMore = false;
+    await loadLogs();
+}
+
+export function setLogSearchInput(value) {
+    state.logs.filters = normalizeLogFilters({
+        ...state.logs.filters,
+        searchInput: value,
+    });
+}
+
+export async function applyLogSearch(value = state.logs.filters.searchInput) {
+    state.logs.filters = normalizeLogFilters({
+        ...state.logs.filters,
+        searchInput: value,
+        search: value,
+    });
+    state.logs.items = [];
+    state.logs.total = 0;
+    state.logs.hasMore = false;
+    await loadLogs();
+}
+
+export async function refreshLogs() {
+    await loadLogs();
+}
+
+export async function loadMoreLogs() {
+    await loadLogs({ append: true });
+}
+
+export async function checkSettingsAppVersion(options = {}) {
+    const silent = Boolean(options.silent);
+
     state.settings.versionCheckLoading = true;
     state.settings.versionCheckError = null;
     emitChange();
@@ -1562,14 +1758,18 @@ export async function checkSettingsAppVersion() {
         const result = response.data ?? null;
 
         state.settings.versionCheck = result;
-        pushToast(
-            result?.updateAvailable ? `SQLite Hub v${result.latestVersion} is available.` : 'SQLite Hub is up to date.',
-            'success',
-        );
+        if (!silent) {
+            pushToast(
+                result?.updateAvailable ? `SQLite Hub v${result.latestVersion} is available.` : 'SQLite Hub is up to date.',
+                'success',
+            );
+        }
         return result;
     } catch (error) {
         state.settings.versionCheckError = normalizeError(error);
-        pushToast('Version check failed.', 'alert');
+        if (!silent) {
+            pushToast('Version check failed.', 'alert');
+        }
         return null;
     } finally {
         state.settings.versionCheckLoading = false;
@@ -2224,6 +2424,94 @@ async function loadData(version, route) {
     }
 }
 
+async function loadTableAdvisorResult(version, tableName) {
+    if (!tableName) {
+        state.tableAdvisor.result = null;
+        state.tableAdvisor.analysisError = null;
+        state.tableAdvisor.analysisLoading = false;
+        return;
+    }
+
+    state.tableAdvisor.analysisLoading = true;
+    state.tableAdvisor.analysisError = null;
+    state.tableAdvisor.result = null;
+    emitChange();
+
+    try {
+        const response = await api.analyzeTableAdvisor(tableName);
+
+        if (version !== routeLoadVersion) {
+            return;
+        }
+
+        state.tableAdvisor.result = response.data ?? null;
+        state.tableAdvisor.analysisError = null;
+    } catch (error) {
+        if (version !== routeLoadVersion) {
+            return;
+        }
+
+        state.tableAdvisor.result = null;
+        state.tableAdvisor.analysisError = normalizeError(error);
+    } finally {
+        if (version === routeLoadVersion) {
+            state.tableAdvisor.analysisLoading = false;
+            emitChange();
+        }
+    }
+}
+
+async function loadTableAdvisor(version, route) {
+    state.tableAdvisor.loading = true;
+    state.tableAdvisor.error = null;
+    state.tableAdvisor.analysisError = null;
+    emitChange();
+
+    try {
+        const response = await api.getDataTables();
+
+        if (version !== routeLoadVersion) {
+            return;
+        }
+
+        const tables = response.data?.tables ?? [];
+        const requestedTableName = route.params?.tableName ?? null;
+        const selectedTableName =
+            requestedTableName && tables.some(table => table.name === requestedTableName)
+                ? requestedTableName
+                : (state.tableAdvisor.selectedTableName && tables.some(table => table.name === state.tableAdvisor.selectedTableName)
+                      ? state.tableAdvisor.selectedTableName
+                      : (tables[0]?.name ?? null));
+
+        state.tableAdvisor.tables = tables;
+        state.tableAdvisor.selectedTableName = selectedTableName;
+        state.tableAdvisor.error = null;
+
+        if (!selectedTableName) {
+            state.tableAdvisor.result = null;
+            return;
+        }
+
+        state.tableAdvisor.loading = false;
+        emitChange();
+        await loadTableAdvisorResult(version, selectedTableName);
+    } catch (error) {
+        if (version !== routeLoadVersion) {
+            return;
+        }
+
+        state.tableAdvisor.tables = [];
+        state.tableAdvisor.selectedTableName = null;
+        state.tableAdvisor.result = null;
+        state.tableAdvisor.error = normalizeError(error);
+    } finally {
+        if (version === routeLoadVersion) {
+            state.tableAdvisor.loading = false;
+            emitChange();
+        }
+    }
+}
+
 async function loadStructureDetail(version) {
     const entry = getCurrentStructureEntry(state);
 
@@ -2671,6 +2959,9 @@ async function loadRouteData(route, options = {}) {
         case 'backups':
             await refreshBackupsState();
             return;
+        case 'logs':
+            await loadLogs();
+            return;
         case 'data':
             await loadData(version, route);
             return;
@@ -2690,12 +2981,17 @@ async function loadRouteData(route, options = {}) {
         case 'tableDesigner':
             await loadTableDesigner(version, route);
             return;
+        case 'tableAdvisor':
+            await loadTableAdvisor(version, route);
+            return;
         case 'mediaTaggingSetup':
         case 'mediaTaggingQueue':
             await loadMediaTagging(version);
             return;
         case 'settings':
             await refreshSettingsState();
+            await refreshSettingsMcpStatus();
+            await checkSettingsAppVersion({ silent: true });
             return;
         default:
     }
@@ -2892,6 +3188,186 @@ export function openDataExportModal() {
     emitChange();
 }
 
+function getGenerateDataModalColumn(modal, columnName) {
+    return (modal?.columns ?? []).find(column => column.name === columnName) ?? null;
+}
+
+function resetGenerateDataPreview(modal) {
+    if (!modal) {
+        return;
+    }
+
+    modal.previewRows = [];
+    modal.previewColumns = (modal.columns ?? []).map(column => column.name);
+}
+
+function buildGenerateDataPayload(modal) {
+    return {
+        rowCount: Number(modal.rowCount ?? 100),
+        mappings: (modal.mappings ?? []).map(mapping => ({
+            columnName: mapping.columnName,
+            generator: mapping.generator,
+            options: { ...(mapping.options ?? {}) },
+        })),
+    };
+}
+
+export function openGenerateDataModal() {
+    const table = state.dataBrowser.table;
+    const tableName = table?.name ?? state.dataBrowser.selectedTable;
+
+    if (!tableName || !table) {
+        pushToast('Select a table before generating rows.', 'alert');
+        return;
+    }
+
+    const columns = (table.columnMeta ?? []).filter(column => column.visible && !column.generated);
+
+    state.modal = {
+        kind: 'generate-data',
+        tableName,
+        columns,
+        rowCount: 100,
+        mappings: buildSyntheticDataMappings(columns, table.foreignKeys ?? []),
+        previewColumns: columns.map(column => column.name),
+        previewRows: [],
+        previewLoading: false,
+        previewRequestId: 0,
+        error: null,
+        submitting: false,
+    };
+    emitChange();
+}
+
+export function updateGenerateDataModal(field, value, options = {}) {
+    if (state.modal?.kind !== 'generate-data') {
+        return;
+    }
+
+    if (field === 'rowCount') {
+        const nextValue = String(value ?? '');
+
+        if (state.modal.rowCount === nextValue) {
+            return;
+        }
+
+        state.modal.rowCount = nextValue;
+        state.modal.error = null;
+        resetGenerateDataPreview(state.modal);
+        if (options.notify !== false) {
+            emitChange();
+        }
+    }
+}
+
+export function updateGenerateDataMapping(columnName, field, value, options = {}) {
+    const modal = state.modal;
+
+    if (modal?.kind !== 'generate-data') {
+        return;
+    }
+
+    const mapping = (modal.mappings ?? []).find(item => item.columnName === columnName);
+
+    if (!mapping) {
+        return;
+    }
+
+    const column = getGenerateDataModalColumn(modal, columnName);
+
+    if (field === 'generator') {
+        const generator = normalizeSyntheticGeneratorType(value, mapping.generator);
+
+        if (mapping.generator === generator) {
+            return;
+        }
+
+        mapping.generator = generator;
+        mapping.options = getDefaultSyntheticOptions(generator, column ?? {});
+    } else {
+        const nextValue = value;
+
+        if ((mapping.options ?? {})[field] === nextValue) {
+            return;
+        }
+
+        mapping.options = {
+            ...(mapping.options ?? {}),
+            [field]: nextValue,
+        };
+    }
+
+    modal.error = null;
+    resetGenerateDataPreview(modal);
+    if (options.notify !== false) {
+        emitChange();
+    }
+}
+
+export async function previewGenerateDataRows() {
+    const modal = state.modal;
+
+    if (modal?.kind !== 'generate-data') {
+        return null;
+    }
+
+    const requestId = (modal.previewRequestId ?? 0) + 1;
+    modal.previewRequestId = requestId;
+    modal.previewLoading = true;
+    modal.error = null;
+    emitChange();
+
+    try {
+        const response = await api.previewSyntheticDataRows(modal.tableName, buildGenerateDataPayload(modal));
+
+        if (state.modal?.kind !== 'generate-data' || state.modal.previewRequestId !== requestId) {
+            return null;
+        }
+
+        state.modal.previewColumns = response.data?.columns ?? [];
+        state.modal.previewRows = response.data?.rows ?? [];
+        state.modal.error = null;
+        return response.data;
+    } catch (error) {
+        if (state.modal?.kind === 'generate-data' && state.modal.previewRequestId === requestId) {
+            state.modal.error = normalizeError(error);
+        }
+
+        return null;
+    } finally {
+        if (state.modal?.kind === 'generate-data' && state.modal.previewRequestId === requestId) {
+            state.modal.previewLoading = false;
+            emitChange();
+        }
+    }
+}
+
+export async function submitGenerateDataRows() {
+    const modal = state.modal;
+
+    if (modal?.kind !== 'generate-data') {
+        return null;
+    }
+
+    startModalSubmission();
+
+    try {
+        const response = await api.insertSyntheticDataRows(modal.tableName, buildGenerateDataPayload(modal));
+
+        if (state.modal?.kind === 'generate-data') {
+            closeModalInternal();
+        }
+
+        pushToast(response.message || `Generated ${response.data?.insertedRowCount ?? modal.rowCount} rows for ${modal.tableName}.`, 'success');
+        await loadDataTable(++routeLoadVersion);
+        clearDataBrowserRowSelectionState();
+        return response.data;
+    } catch (error) {
+        withModalError(error);
+        return null;
+    }
+}
+
 export function openCopyColumnModal({ scope = 'editor', columnName = '', mode = 'column' } = {}) {
     const resultScope = normalizeCopyColumnScope(scope);
     const normalizedColumnName = String(columnName ?? '');

package/frontend/js/utils/inputClear.js

@@ -0,0 +1,36 @@
+const ESCAPE_CLEARABLE_INPUT_TYPES = new Set([
+    '',
+    'email',
+    'number',
+    'password',
+    'search',
+    'tel',
+    'text',
+    'url',
+]);
+
+export function isEscapeClearableInput(input) {
+    const type = String(input?.type ?? 'text').trim().toLowerCase();
+
+    return (
+        Boolean(input) &&
+        typeof input.value === 'string' &&
+        !input.disabled &&
+        !input.readOnly &&
+        ESCAPE_CLEARABLE_INPUT_TYPES.has(type)
+    );
+}
+
+export function clearInputForEscape(input, createInputEvent = () => new Event('input', { bubbles: true })) {
+    if (!isEscapeClearableInput(input) || input.value === '') {
+        return false;
+    }
+
+    input.value = '';
+
+    if (typeof input.dispatchEvent === 'function') {
+        input.dispatchEvent(createInputEvent());
+    }
+
+    return true;
+}