sqlite-hub 1.1.2 → 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 = {
@@ -82,6 +86,7 @@ let chartsLoadVersion = 0;
 let chartsDetailLoadVersion = 0;
 let mediaTaggingPreviewVersion = 0;
 let documentsLoadVersion = 0;
+let lastOpenDocumentId = null;
 
 function readStoredDataPageSize(fallback = DEFAULT_DATA_PAGE_SIZE) {
     try {
@@ -270,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 },
@@ -550,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();
 
@@ -863,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;
@@ -1003,6 +1120,10 @@ function applyCurrentDocument(document) {
     state.documents.draftContent = document?.content ?? '';
     state.documents.dirty = false;
     state.documents.saveError = null;
+
+    if (document?.id) {
+        lastOpenDocumentId = document.id;
+    }
 }
 
 function upsertDocumentSummary(document) {
@@ -1319,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 = [];
     }
@@ -1374,6 +1499,7 @@ async function refreshBackupsState() {
     if (!state.connections.active) {
         state.backups.items = [];
         state.backups.error = null;
+        state.backups.diff = createEmptyBackupDiffState();
         emitChange();
         return;
     }
@@ -1951,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;
@@ -2006,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) {
@@ -2066,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;
@@ -2425,7 +2563,12 @@ async function previewMediaTaggingDraft(options = {}) {
 function invalidateDatabaseCaches(options = {}) {
     const preserveDataBrowserState = options.preserveDataBrowserState === true;
 
+    if (!preserveDataBrowserState) {
+        lastOpenDocumentId = null;
+    }
+
     state.overview.data = null;
+    state.backups.diff = createEmptyBackupDiffState();
     state.dataBrowser.tables = [];
     if (!preserveDataBrowserState) {
         state.dataBrowser.selectedTable = null;
@@ -2932,7 +3075,7 @@ function buildDocumentMarkdownInsertion(currentContent, insertion, range = null)
     return `${before}${prefix}${text}${suffix}${after}`;
 }
 
-function insertMarkdownIntoCurrentDocumentDraft(markdown, range = null) {
+export function insertMarkdownIntoCurrentDocumentDraft(markdown, range = null) {
     if (!state.documents.selectedId) {
         return false;
     }
@@ -2950,6 +3093,63 @@ function insertMarkdownIntoCurrentDocumentDraft(markdown, range = null) {
     return true;
 }
 
+export async function insertMarkdownIntoLastOpenDocument(markdown) {
+    if (state.route.name === 'documents' && state.documents.selectedId) {
+        const inserted = insertMarkdownIntoCurrentDocumentDraft(markdown);
+
+        return {
+            documentId: state.documents.selectedId,
+            inserted,
+            saved: false,
+        };
+    }
+
+    const documentId = lastOpenDocumentId ?? state.documents.selectedId;
+
+    if (!documentId) {
+        return {
+            documentId: null,
+            inserted: false,
+            saved: false,
+        };
+    }
+
+    const response = await api.getDocument(documentId);
+    const document = response.data ?? null;
+
+    if (!document?.id) {
+        return {
+            documentId: null,
+            inserted: false,
+            saved: false,
+        };
+    }
+
+    const nextContent = buildDocumentMarkdownInsertion(document.content, markdown);
+
+    if (nextContent === document.content) {
+        return {
+            documentId: document.id,
+            inserted: false,
+            saved: false,
+        };
+    }
+
+    const updateResponse = await api.updateDocument(document.id, {
+        content: nextContent,
+    });
+    const updatedDocument = updateResponse.data ?? document;
+
+    lastOpenDocumentId = updatedDocument.id;
+    upsertDocumentSummary(updatedDocument);
+
+    return {
+        documentId: updatedDocument.id,
+        inserted: true,
+        saved: true,
+    };
+}
+
 function getDocumentInsertQueryTitle(query) {
     return query?.displayTitle || query?.title || query?.previewSql || query?.rawSql || 'Saved query';
 }
@@ -3910,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) {
@@ -3919,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 ?? '',
@@ -3929,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;
     }
 
@@ -3939,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);
@@ -3986,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;
@@ -4016,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));
 
@@ -4444,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);

package/frontend/js/utils/emailPreview.js

@@ -0,0 +1,28 @@
+const EMAIL_PATTERN = /^[^\s@<>"']+@[^\s@<>"']+\.[^\s@<>"']+$/;
+
+export function detectEmailValue(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+
+  const text = value.trim();
+
+  if (!text || text.length > 320 || !EMAIL_PATTERN.test(text)) {
+    return null;
+  }
+
+  const atIndex = text.lastIndexOf("@");
+  const localPart = text.slice(0, atIndex);
+  const domain = text.slice(atIndex + 1);
+
+  if (!localPart || !domain || domain.startsWith(".") || domain.endsWith(".")) {
+    return null;
+  }
+
+  return {
+    type: "email",
+    value: text,
+    localPart,
+    domain,
+  };
+}

package/frontend/js/utils/markdownDocuments.js

@@ -83,8 +83,24 @@ function renderFallbackMarkdown(markdown = '') {
     return html.join('\n');
 }
 
+function escapeMarkdownHtmlOutsideFences(markdown = '') {
+    const lines = String(markdown ?? '').split('\n');
+    let inFence = false;
+
+    return lines
+        .map(line => {
+            if (FENCED_CODE_PATTERN.test(line)) {
+                inFence = !inFence;
+                return line;
+            }
+
+            return inFence ? line : escapeHtml(line);
+        })
+        .join('\n');
+}
+
 function renderMarkdownBlock(markdown = '') {
-    const source = escapeHtml(markdown);
+    const source = escapeMarkdownHtmlOutsideFences(markdown);
     const markedRuntime = globalThis.marked;
     const parser = typeof markedRuntime?.parse === 'function' ? markedRuntime.parse.bind(markedRuntime) : null;