sqlite-hub 1.2.0 → 1.5.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,7 +64,18 @@ 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']);
+const TYPE_GENERATION_NULLABLE = new Set(['native', 'optional']);
+const TYPE_GENERATION_JSON_TYPES = new Set(['unknown', 'record', 'json-value']);
 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 = {
@@ -254,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: {} },
@@ -271,6 +305,18 @@ const state = {
         loading: false,
         operationLoading: false,
         error: null,
+        diff: {
+            visible: false,
+            backupId: null,
+            backupName: '',
+            backupCreatedAt: null,
+            currentLabel: '',
+            activeTab: 'schema',
+            requestId: null,
+            loading: false,
+            error: null,
+            data: null,
+        },
     },
     settings: {
         data: { ...DEFAULT_SETTINGS },
@@ -292,6 +338,18 @@ const state = {
         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,
@@ -316,6 +374,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),
@@ -551,6 +618,21 @@ function getMediaTaggingRouteErrorKey(error = {}) {
     return `route:${String(error.code ?? '').trim()}:${String(error.message ?? '').trim()}`;
 }
 
+function createEmptyBackupDiffState() {
+    return {
+        visible: false,
+        backupId: null,
+        backupName: '',
+        backupCreatedAt: null,
+        currentLabel: '',
+        activeTab: 'schema',
+        requestId: null,
+        loading: false,
+        error: null,
+        data: null,
+    };
+}
+
 function syncDismissedMediaTaggingIssues() {
     const availableKeys = new Set();
 
@@ -591,6 +673,7 @@ function requiresActiveDatabase(routeName) {
     return [
         'overview',
         'backups',
+        'logs',
         'data',
         'editor',
         'editorResults',
@@ -598,6 +681,7 @@ function requiresActiveDatabase(routeName) {
         'documents',
         'structure',
         'tableDesigner',
+        'tableAdvisor',
         'mediaTaggingSetup',
         'mediaTaggingQueue',
     ].includes(routeName);
@@ -864,6 +948,91 @@ function findDataBrowserRowIndexByIdentity(rows = [], identity) {
     return rows.findIndex(row => areRowIdentitiesEqual(row?.__identity, identity));
 }
 
+function coerceDataRouteIdentityValue(column, value) {
+    const text = String(value ?? '');
+    const affinity = String(column?.affinity ?? '').toUpperCase();
+
+    if (['INTEGER', 'REAL', 'NUMERIC'].includes(affinity) && text.trim() !== '') {
+        const numberValue = Number(text);
+
+        if (Number.isFinite(numberValue)) {
+            return numberValue;
+        }
+    }
+
+    return value;
+}
+
+function parseCompositeDataRoutePrimaryKey(rawValue) {
+    try {
+        const parsed = JSON.parse(rawValue);
+
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    } catch {
+        return null;
+    }
+
+    return null;
+}
+
+function buildDataRouteRowIdentity(table, rawPrimaryKey) {
+    const primaryKeyValue = String(rawPrimaryKey ?? '').trim();
+    const identityStrategy = table?.identityStrategy ?? null;
+
+    if (!primaryKeyValue || !identityStrategy) {
+        return null;
+    }
+
+    if (identityStrategy.type === 'rowid') {
+        const numberValue = Number(primaryKeyValue);
+
+        return {
+            kind: 'rowid',
+            values: {
+                rowid: Number.isInteger(numberValue) ? numberValue : primaryKeyValue,
+            },
+        };
+    }
+
+    if (identityStrategy.type !== 'primaryKey') {
+        return null;
+    }
+
+    const columns = identityStrategy.columns ?? [];
+
+    if (columns.length === 1) {
+        const columnName = columns[0];
+        const column = table?.columnMeta?.find(candidate => candidate.name === columnName);
+
+        return {
+            kind: 'primaryKey',
+            columns,
+            values: {
+                [columnName]: coerceDataRouteIdentityValue(column, primaryKeyValue),
+            },
+        };
+    }
+
+    const parsedValue = parseCompositeDataRoutePrimaryKey(primaryKeyValue);
+
+    if (!parsedValue || columns.some(columnName => !Object.prototype.hasOwnProperty.call(parsedValue, columnName))) {
+        return null;
+    }
+
+    return {
+        kind: 'primaryKey',
+        columns,
+        values: Object.fromEntries(
+            columns.map(columnName => {
+                const column = table?.columnMeta?.find(candidate => candidate.name === columnName);
+                return [columnName, coerceDataRouteIdentityValue(column, parsedValue[columnName])];
+            }),
+        ),
+    };
+}
+
 function clearDataBrowserRowSelectionState() {
     state.dataBrowser.selectedRowIndex = null;
     state.dataBrowser.selectedRow = null;
@@ -1174,6 +1343,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;
@@ -1181,6 +1351,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;
@@ -1194,6 +1366,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 = [];
@@ -1234,6 +1415,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;
@@ -1324,6 +1513,10 @@ function syncRouteContext() {
         state.documents.saveError = null;
     }
 
+    if (route.name !== 'backups') {
+        state.backups.diff = createEmptyBackupDiffState();
+    }
+
     if (route.name !== 'mediaTaggingSetup' && route.name !== 'mediaTaggingQueue') {
         state.mediaTagging.selectedTagKeys = [];
     }
@@ -1375,10 +1568,70 @@ async function refreshSettingsState() {
     }
 }
 
+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 = [];
         state.backups.error = null;
+        state.backups.diff = createEmptyBackupDiffState();
         emitChange();
         return;
     }
@@ -1431,6 +1684,48 @@ export function setSettingsSection(section) {
     emitChange();
 }
 
+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() {
     state.settings.versionCheckLoading = true;
     state.settings.versionCheckError = null;
@@ -1956,8 +2251,9 @@ async function resolvePendingDataBrowserRow(version) {
     }
 }
 
-async function loadDataTable(version) {
+async function loadDataTable(version, options = {}) {
     const tableName = state.dataBrowser.selectedTable;
+    const routeRowPrimaryKey = options.rowPrimaryKey ?? null;
     const pageSize = normalizeDataPageSize(state.dataBrowser.pageSize, DEFAULT_DATA_PAGE_SIZE);
     const page = Math.max(1, Number(state.dataBrowser.page) || 1);
     const sortColumn = state.dataBrowser.sortColumn;
@@ -2011,6 +2307,15 @@ async function loadDataTable(version) {
             state.dataBrowser.searchColumn,
         );
         clearDataBrowserRowSelectionState();
+        const routeRowIdentity = buildDataRouteRowIdentity(state.dataBrowser.table, routeRowPrimaryKey);
+        if (routeRowPrimaryKey !== null && routeRowPrimaryKey !== undefined) {
+            state.dataBrowser.pendingOpenRow = routeRowIdentity
+                ? {
+                      tableName,
+                      identity: routeRowIdentity,
+                  }
+                : null;
+        }
         await resolvePendingDataBrowserRow(version);
     } catch (error) {
         if (version !== routeLoadVersion) {
@@ -2071,7 +2376,9 @@ async function loadData(version, route) {
             return;
         }
 
-        await loadDataTable(version);
+        await loadDataTable(version, {
+            rowPrimaryKey: route.params?.rowPrimaryKey ?? null,
+        });
     } catch (error) {
         if (version !== routeLoadVersion) {
             return;
@@ -2091,6 +2398,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);
 
@@ -2435,6 +2830,7 @@ function invalidateDatabaseCaches(options = {}) {
     }
 
     state.overview.data = null;
+    state.backups.diff = createEmptyBackupDiffState();
     state.dataBrowser.tables = [];
     if (!preserveDataBrowserState) {
         state.dataBrowser.selectedTable = null;
@@ -2537,6 +2933,9 @@ async function loadRouteData(route, options = {}) {
         case 'backups':
             await refreshBackupsState();
             return;
+        case 'logs':
+            await loadLogs();
+            return;
         case 'data':
             await loadData(version, route);
             return;
@@ -2556,6 +2955,9 @@ 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);
@@ -2758,6 +3160,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 ?? '');
@@ -3976,7 +4558,7 @@ export async function submitCreateBackupConfirmation({ name = '', notes = '', ty
     }
 }
 
-export function openEditBackupNotesModal(backupId) {
+export function openEditBackupModal(backupId) {
     const backup = state.backups.items.find(item => String(item.id) === String(backupId));
 
     if (!backup) {
@@ -3985,7 +4567,7 @@ export function openEditBackupNotesModal(backupId) {
     }
 
     state.modal = {
-        kind: 'edit-backup-notes',
+        kind: 'edit-backup',
         backupId: backup.id,
         backupName: backup.name,
         notes: backup.notes ?? '',
@@ -3995,8 +4577,8 @@ export function openEditBackupNotesModal(backupId) {
     emitChange();
 }
 
-export async function submitEditBackupNotesConfirmation(notes = '') {
-    if (state.modal?.kind !== 'edit-backup-notes') {
+export async function submitEditBackupConfirmation({ name = '', notes = '' } = {}) {
+    if (state.modal?.kind !== 'edit-backup') {
         return null;
     }
 
@@ -4005,12 +4587,12 @@ export async function submitEditBackupNotesConfirmation(notes = '') {
     state.backups.operationLoading = true;
 
     try {
-        const response = await api.updateBackup(backupId, { notes });
+        const response = await api.updateBackup(backupId, { name, notes });
         state.backups.items = state.backups.items.map(item =>
             String(item.id) === String(response.data.id) ? response.data : item
         );
         closeModalInternal();
-        pushToast(response.message || 'Backup notes updated.', 'success');
+        pushToast(response.message || 'Backup updated.', 'success');
         return response.data;
     } catch (error) {
         withModalError(error);
@@ -4052,6 +4634,9 @@ export async function submitDeleteBackupConfirmation() {
     try {
         const response = await api.deleteBackup(backupId);
         state.backups.items = state.backups.items.filter(item => String(item.id) !== String(backupId));
+        if (String(state.backups.diff.backupId ?? '') === String(backupId)) {
+            state.backups.diff = createEmptyBackupDiffState();
+        }
         closeModalInternal();
         pushToast(response.message || 'Backup deleted.', 'muted');
         return true;
@@ -4082,6 +4667,75 @@ export async function downloadBackup(backupId) {
     }
 }
 
+export async function openBackupDiffDrawer(backupId) {
+    const backup = state.backups.items.find(item => String(item.id) === String(backupId));
+
+    if (!backup) {
+        pushToast('The selected backup could not be loaded.', 'alert');
+        return null;
+    }
+
+    const requestId = crypto.randomUUID();
+    state.backups.diff = {
+        visible: true,
+        backupId: backup.id,
+        backupName: backup.name,
+        backupCreatedAt: backup.createdAt,
+        currentLabel: state.connections.active?.label ?? 'Current database',
+        activeTab: 'schema',
+        requestId,
+        loading: true,
+        error: null,
+        data: null,
+    };
+    state.backups.operationLoading = true;
+    emitChange();
+
+    try {
+        const response = await api.getBackupDiff(backup.id);
+
+        if (state.backups.diff.requestId === requestId) {
+            state.backups.diff.data = response.data ?? null;
+            state.backups.diff.backupName = response.data?.backup?.name ?? state.backups.diff.backupName;
+            state.backups.diff.backupCreatedAt = response.data?.backup?.createdAt ?? state.backups.diff.backupCreatedAt;
+            state.backups.diff.currentLabel = response.data?.current?.label ?? state.backups.diff.currentLabel;
+            state.backups.diff.error = null;
+        }
+
+        return response.data ?? null;
+    } catch (error) {
+        if (state.backups.diff.requestId === requestId) {
+            state.backups.diff.error = normalizeError(error);
+        } else {
+            pushToast(normalizeError(error).message || 'Backup comparison failed.', 'alert');
+        }
+
+        return null;
+    } finally {
+        state.backups.operationLoading = false;
+
+        if (state.backups.diff.requestId === requestId) {
+            state.backups.diff.loading = false;
+        }
+
+        emitChange();
+    }
+}
+
+export function setBackupDiffTab(tab) {
+    if (!state.backups.diff.visible) {
+        return;
+    }
+
+    state.backups.diff.activeTab = tab === 'data' ? 'data' : 'schema';
+    emitChange();
+}
+
+export function closeBackupDiffDrawer() {
+    state.backups.diff = createEmptyBackupDiffState();
+    emitChange();
+}
+
 export function openRestoreBackupModal(backupId) {
     const backup = state.backups.items.find(item => String(item.id) === String(backupId));
 
@@ -4510,6 +5164,214 @@ export async function selectStructureEntry(name) {
     await loadStructureDetail(++routeLoadVersion);
 }
 
+function getDefaultTypeGenerationOptions(target = 'typescript') {
+    const propertyNaming = target === 'rust' ? 'snake' : 'camel';
+
+    return {
+        typeName: '',
+        propertyNaming,
+        nullableMode: 'native',
+        includeComments: false,
+        includeDefaultsAsComments: false,
+        includeGeneratedColumns: true,
+        includeHiddenColumns: false,
+        exportDeclaration: true,
+        jsonType: 'unknown',
+    };
+}
+
+function normalizeTypeGenerationOptions(options = {}, target = 'typescript') {
+    const defaults = getDefaultTypeGenerationOptions(target);
+    const propertyNaming = TYPE_GENERATION_NAMING.has(options.propertyNaming)
+        ? options.propertyNaming
+        : defaults.propertyNaming;
+    const nullableMode =
+        TYPE_GENERATION_NULLABLE.has(options.nullableMode) && (target === 'typescript' || options.nullableMode !== 'optional')
+            ? options.nullableMode
+            : 'native';
+    const jsonType = TYPE_GENERATION_JSON_TYPES.has(options.jsonType) ? options.jsonType : 'unknown';
+
+    return {
+        ...defaults,
+        ...options,
+        propertyNaming,
+        nullableMode,
+        jsonType,
+        typeName: String(options.typeName ?? ''),
+    };
+}
+
+function getStructureTableNames() {
+    return (state.structure.data?.grouped?.tables ?? [])
+        .filter(table => table?.type === 'table')
+        .map(table => String(table.name ?? '').trim())
+        .filter(Boolean);
+}
+
+function getTypeGenerationRequestOptions(modal) {
+    const options = { ...modal.options };
+
+    if (!String(options.typeName ?? '').trim()) {
+        delete options.typeName;
+    }
+
+    if (modal.target !== 'typescript') {
+        delete options.jsonType;
+    }
+
+    return options;
+}
+
+function combineGeneratedTypeFiles(files = []) {
+    return files
+        .map(file => [`// ${file.fileName}`, file.code].filter(Boolean).join('\n'))
+        .join('\n\n');
+}
+
+async function refreshTypeGenerationPreview() {
+    const modal = state.modal;
+
+    if (modal?.kind !== 'generate-types') {
+        return;
+    }
+
+    const requestId = (modal.previewRequestId ?? 0) + 1;
+    modal.previewRequestId = requestId;
+    modal.loading = true;
+    modal.error = null;
+    emitChange();
+
+    try {
+        const options = getTypeGenerationRequestOptions(modal);
+        const isAllTables = modal.scope === 'all';
+        const tableNames = isAllTables ? modal.tableNames : [modal.tableName];
+
+        if (!tableNames.length) {
+            throw new Error('No tables available for type generation.');
+        }
+
+        const responses = await Promise.all(
+            tableNames.map(async tableName => {
+                const response = await api.generateStructureTypes(tableName, {
+                    target: modal.target,
+                    options,
+                });
+
+                return {
+                    ...response.data,
+                    tableName,
+                    warnings: response.warnings ?? [],
+                    metadata: response.metadata ?? {},
+                };
+            }),
+        );
+
+        if (state.modal?.kind !== 'generate-types' || state.modal.previewRequestId !== requestId) {
+            return;
+        }
+
+        if (isAllTables) {
+            state.modal.result = {
+                scope: 'all',
+                target: modal.target,
+                fileName: `${responses.length} files`,
+                files: responses,
+                code: combineGeneratedTypeFiles(responses),
+            };
+            state.modal.warnings = responses.flatMap(file =>
+                (file.warnings ?? []).map(warning => `${file.tableName}: ${warning}`),
+            );
+            state.modal.metadata = {
+                fileCount: responses.length,
+                columnCount: responses.reduce((count, file) => count + Number(file.metadata?.columnCount ?? 0), 0),
+            };
+        } else {
+            const [response] = responses;
+            state.modal.result = response;
+            state.modal.warnings = response.warnings ?? [];
+            state.modal.metadata = response.metadata ?? {};
+        }
+    } catch (error) {
+        if (state.modal?.kind !== 'generate-types' || state.modal.previewRequestId !== requestId) {
+            return;
+        }
+
+        state.modal.error = normalizeError(error);
+        state.modal.result = null;
+        state.modal.warnings = error.warnings ?? [];
+    } finally {
+        if (state.modal?.kind === 'generate-types' && state.modal.previewRequestId === requestId) {
+            state.modal.loading = false;
+            emitChange();
+        }
+    }
+}
+
+export async function openGenerateTypesModal(tableName, target = 'typescript', scope = 'selected') {
+    const normalizedTarget = TYPE_GENERATION_TARGETS.has(target) ? target : 'typescript';
+    const normalizedScope = scope === 'all' ? 'all' : 'selected';
+    const tableNames = getStructureTableNames();
+    const normalizedTableName = String(tableName ?? state.structure.selectedName ?? '').trim();
+
+    if (normalizedScope === 'all' && !tableNames.length) {
+        pushToast('No tables available for type generation.', 'alert');
+        return;
+    }
+
+    if (normalizedScope === 'selected' && !normalizedTableName) {
+        pushToast('Select a table before generating types.', 'alert');
+        return;
+    }
+
+    state.modal = {
+        kind: 'generate-types',
+        scope: normalizedScope,
+        tableName: normalizedScope === 'all' ? '' : normalizedTableName,
+        tableNames: normalizedScope === 'all' ? tableNames : [],
+        target: normalizedTarget,
+        options: getDefaultTypeGenerationOptions(normalizedTarget),
+        result: null,
+        warnings: [],
+        metadata: {},
+        loading: false,
+        error: null,
+        submitting: false,
+    };
+    emitChange();
+    await refreshTypeGenerationPreview();
+}
+
+export async function updateGenerateTypesModal(field, value) {
+    if (state.modal?.kind !== 'generate-types') {
+        return;
+    }
+
+    if (field === 'target') {
+        const target = TYPE_GENERATION_TARGETS.has(value) ? value : 'typescript';
+        state.modal.target = target;
+        state.modal.options = normalizeTypeGenerationOptions(
+            {
+                ...state.modal.options,
+                propertyNaming: getDefaultTypeGenerationOptions(target).propertyNaming,
+            },
+            target,
+        );
+    } else if (field in state.modal.options) {
+        const booleanFields = new Set([
+            'includeComments',
+            'includeDefaultsAsComments',
+            'includeGeneratedColumns',
+            'includeHiddenColumns',
+            'exportDeclaration',
+        ]);
+        state.modal.options[field] = booleanFields.has(field) ? Boolean(value) : String(value ?? '');
+        state.modal.options = normalizeTypeGenerationOptions(state.modal.options, state.modal.target);
+    }
+
+    emitChange();
+    await refreshTypeGenerationPreview();
+}
+
 export function toggleStructureTablesPanel() {
     state.structure.tablesVisible = state.structure.tablesVisible === false;
     storeBoolean(UI_PREFERENCE_STORAGE_KEYS.structureTablesVisible, state.structure.tablesVisible);