sqlite-hub 1.2.0 → 1.4.0

package/frontend/js/store.js

@@ -60,6 +60,10 @@ const UI_PREFERENCE_STORAGE_KEYS = {
 const QUERY_HISTORY_PAGE_SIZE = 30;
 const QUERY_HISTORY_RUN_LIMIT = 8;
 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 = {
@@ -271,6 +275,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 },
@@ -551,6 +567,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();
 
@@ -864,6 +895,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;
@@ -1324,6 +1440,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 = [];
     }
@@ -1379,6 +1499,7 @@ async function refreshBackupsState() {
     if (!state.connections.active) {
         state.backups.items = [];
         state.backups.error = null;
+        state.backups.diff = createEmptyBackupDiffState();
         emitChange();
         return;
     }
@@ -1956,8 +2077,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 +2133,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 +2202,9 @@ async function loadData(version, route) {
             return;
         }
 
-        await loadDataTable(version);
+        await loadDataTable(version, {
+            rowPrimaryKey: route.params?.rowPrimaryKey ?? null,
+        });
     } catch (error) {
         if (version !== routeLoadVersion) {
             return;
@@ -2435,6 +2568,7 @@ function invalidateDatabaseCaches(options = {}) {
     }
 
     state.overview.data = null;
+    state.backups.diff = createEmptyBackupDiffState();
     state.dataBrowser.tables = [];
     if (!preserveDataBrowserState) {
         state.dataBrowser.selectedTable = null;
@@ -3976,7 +4110,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 +4119,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 +4129,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 +4139,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 +4186,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 +4219,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 +4716,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);