sqlite-hub 1.2.0 → 1.5.0

package/server/services/sqlite/backupService.js

@@ -19,6 +19,10 @@ const {
   validateSqlitePath,
 } = require("../../utils/fileValidation");
 const { quoteIdentifier } = require("../../utils/identifier");
+const {
+  buildBackupDiff,
+  normalizeBackupDiffSampleLimit,
+} = require("./backupDiff");
 
 const BACKUP_TYPES = new Set([
   "manual",
@@ -161,8 +165,9 @@ class BackupService {
     return this.decorateBackupFileState(backup);
   }
 
-  updateBackupNotes(backupId, notes = "") {
+  updateBackupDetails(backupId, { name, notes } = {}) {
     const backup = this.appStateStore.updateBackupRecord(backupId, {
+      name,
       notes,
     });
 
@@ -393,6 +398,77 @@ class BackupService {
     };
   }
 
+  backupBelongsToConnection(backup, connection) {
+    if (!backup || !connection) {
+      return false;
+    }
+
+    if (backup.connectionId && backup.connectionId === connection.id) {
+      return true;
+    }
+
+    if (backup.sourcePath && connection.path) {
+      return path.resolve(backup.sourcePath) === path.resolve(connection.path);
+    }
+
+    return false;
+  }
+
+  diffBackupWithCurrent(backupId, { sampleLimit } = {}) {
+    const normalizedSampleLimit = normalizeBackupDiffSampleLimit(sampleLimit);
+    const activeConnection = this.connectionManager.getActiveConnection();
+
+    if (!activeConnection) {
+      throw new DatabaseRequiredError("No active SQLite database selected for backup comparison.");
+    }
+
+    if (this.activeOperations.size > 0) {
+      throw new ConflictError("A backup operation is already running.");
+    }
+
+    const backup = this.getBackup(backupId);
+
+    if (backup.status !== "verified") {
+      throw new ValidationError("Only verified backups can be compared.");
+    }
+
+    if (!backup.fileExists) {
+      throw new NotFoundError("Backup file is missing.");
+    }
+
+    if (!this.backupBelongsToConnection(backup, activeConnection)) {
+      throw new ValidationError("Backup does not belong to the active database.");
+    }
+
+    let backupDb = null;
+
+    try {
+      backupDb = new Database(backup.path, {
+        readonly: true,
+        fileMustExist: true,
+      });
+
+      const quickCheck = readQuickCheckResult(backupDb);
+
+      if (quickCheck !== "ok") {
+        throw new ValidationError(`Backup verification failed: ${quickCheck}`);
+      }
+
+      return buildBackupDiff({
+        backupDb,
+        currentDb: this.connectionManager.getActiveDatabase(),
+        backup,
+        currentConnection: activeConnection,
+        comparedAt: new Date(),
+        sampleLimit: normalizedSampleLimit,
+      });
+    } catch (error) {
+      throw mapSqliteError(error);
+    } finally {
+      backupDb?.close();
+    }
+  }
+
   deleteBackup(backupId) {
     const backup = this.getBackup(backupId);
 

package/server/services/sqlite/dataBrowserService.js

@@ -6,6 +6,12 @@ const {
   serializeRows,
 } = require("../../utils/sqliteTypes");
 const { getRawStructureEntries, getTableDetail } = require("./introspection");
+const {
+  PREVIEW_ROW_COUNT,
+  buildSyntheticRows,
+  insertSyntheticRows,
+} = require("./syntheticDataGenerator");
+const { analyzeTable } = require("./tableAdvisor");
 const { normalizeTableFilter } = require("./tableFilter");
 const { buildTableOrderClause, normalizeTableSort } = require("./tableSort");
 
@@ -272,6 +278,36 @@ class DataBrowserService {
     };
   }
 
+  previewSyntheticRows(tableName, payload = {}) {
+    const db = this.connectionManager.getActiveDatabase();
+    const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
+    const preview = buildSyntheticRows(db, tableDetail, payload, { limit: PREVIEW_ROW_COUNT });
+
+    return {
+      tableName: tableDetail.name,
+      rowCount: preview.rowCount,
+      previewRowCount: preview.previewRowCount,
+      columns: preview.columns,
+      rows: serializeRows(preview.rows),
+      mappings: preview.mappings,
+    };
+  }
+
+  insertSyntheticRows(tableName, payload = {}) {
+    this.connectionManager.assertWritable();
+
+    const db = this.connectionManager.getActiveDatabase();
+    const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
+
+    return insertSyntheticRows(db, tableDetail, payload);
+  }
+
+  analyzeTable(tableName) {
+    const db = this.connectionManager.getActiveDatabase();
+
+    return analyzeTable(db, tableName);
+  }
+
   buildWhereClause(tableDetail, identity) {
     if (tableDetail.identityStrategy?.type === "rowid") {
       const rowid = identity?.values?.rowid;

package/server/services/sqlite/introspection.js

@@ -160,35 +160,66 @@ function normalizeIdentifier(value) {
   return text.toLowerCase();
 }
 
-function parseSqlStringList(text = "") {
+function parseSqlStringLiteral(text = "", startIndex = 0) {
+  let value = "";
+  let index = startIndex + 1;
+
+  while (index < text.length) {
+    if (text[index] === "'") {
+      if (text[index + 1] === "'") {
+        value += "'";
+        index += 2;
+        continue;
+      }
+
+      return {
+        value,
+        nextIndex: index + 1,
+      };
+    }
+
+    value += text[index];
+    index += 1;
+  }
+
+  return null;
+}
+
+function parseSqlSimpleListValues(text = "") {
   const values = [];
   let index = 0;
 
   while (index < text.length) {
-    if (text[index] !== "'") {
+    const character = text[index];
+
+    if (/\s|,/.test(character)) {
       index += 1;
       continue;
     }
 
-    let value = "";
-    index += 1;
-
-    while (index < text.length) {
-      if (text[index] === "'") {
-        if (text[index + 1] === "'") {
-          value += "'";
-          index += 2;
-          continue;
-        }
+    if (character === "'") {
+      const parsed = parseSqlStringLiteral(text, index);
 
-        index += 1;
-        values.push(value);
-        break;
+      if (!parsed) {
+        return [];
       }
 
-      value += text[index];
-      index += 1;
+      values.push(parsed.value);
+      index = parsed.nextIndex;
+      continue;
+    }
+
+    const commaIndex = text.indexOf(",", index);
+    const endIndex = commaIndex === -1 ? text.length : commaIndex;
+    const token = text.slice(index, endIndex).trim();
+    const number = parseSqlNumberToken(token);
+
+    if (number === null) {
+      return [];
     }
+
+    values.push(number);
+    index = endIndex;
   }
 
   return values;
@@ -219,7 +250,7 @@ function findColumnInListExpression(expression, columnName) {
       continue;
     }
 
-    const values = parseSqlStringList(expression.slice(openIndex + 1, closeIndex));
+    const values = parseSqlSimpleListValues(expression.slice(openIndex + 1, closeIndex));
 
     if (values.length) {
       return values;
@@ -229,6 +260,137 @@ function findColumnInListExpression(expression, columnName) {
   return [];
 }
 
+const SQL_IDENTIFIER_SOURCE =
+  '(?:"(?:[^"]|"")+"|`(?:[^`]|``)+`|\\[[^\\]]+\\]|[A-Za-z_][A-Za-z0-9_$]*)';
+const SQL_NUMBER_SOURCE = "[+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:e[+-]?\\d+)?";
+const SQL_NUMBER_EXACT_PATTERN = new RegExp(`^${SQL_NUMBER_SOURCE}$`, "i");
+
+function parseSqlNumberToken(value) {
+  const text = String(value ?? "").trim();
+
+  if (!SQL_NUMBER_EXACT_PATTERN.test(text)) {
+    return null;
+  }
+
+  const number = Number(text);
+
+  return Number.isFinite(number) ? number : null;
+}
+
+function tokenMatchesColumn(token, columnName) {
+  return normalizeIdentifier(token) === normalizeIdentifier(columnName);
+}
+
+function applyIntegerLowerBound(range, value, inclusive) {
+  const min = inclusive ? Math.ceil(value) : Math.floor(value) + 1;
+
+  range.min = range.min === null ? min : Math.max(range.min, min);
+}
+
+function applyIntegerUpperBound(range, value, inclusive) {
+  const max = inclusive ? Math.floor(value) : Math.ceil(value) - 1;
+
+  range.max = range.max === null ? max : Math.min(range.max, max);
+}
+
+function applyIntegerComparison(range, operator, value) {
+  switch (operator) {
+    case ">":
+      applyIntegerLowerBound(range, value, false);
+      break;
+    case ">=":
+      applyIntegerLowerBound(range, value, true);
+      break;
+    case "<":
+      applyIntegerUpperBound(range, value, false);
+      break;
+    case "<=":
+      applyIntegerUpperBound(range, value, true);
+      break;
+    case "=":
+      applyIntegerLowerBound(range, value, true);
+      applyIntegerUpperBound(range, value, true);
+      break;
+    default:
+      break;
+  }
+}
+
+function reverseComparisonOperator(operator) {
+  return {
+    ">": "<",
+    ">=": "<=",
+    "<": ">",
+    "<=": ">=",
+    "=": "=",
+  }[operator];
+}
+
+function findColumnIntegerRangeInExpression(expression, columnName) {
+  const range = { min: null, max: null };
+  let found = false;
+  const betweenPattern = new RegExp(
+    `(${SQL_IDENTIFIER_SOURCE})\\s+BETWEEN\\s+(${SQL_NUMBER_SOURCE})\\s+AND\\s+(${SQL_NUMBER_SOURCE})`,
+    "gi"
+  );
+  const comparisonPattern = new RegExp(
+    `(${SQL_IDENTIFIER_SOURCE}|${SQL_NUMBER_SOURCE})\\s*(<=|>=|=|<|>)\\s*(${SQL_IDENTIFIER_SOURCE}|${SQL_NUMBER_SOURCE})`,
+    "gi"
+  );
+  let match;
+
+  while ((match = betweenPattern.exec(expression))) {
+    const identifier = match[1];
+    const min = parseSqlNumberToken(match[2]);
+    const max = parseSqlNumberToken(match[3]);
+
+    if (!tokenMatchesColumn(identifier, columnName) || min === null || max === null) {
+      continue;
+    }
+
+    applyIntegerLowerBound(range, min, true);
+    applyIntegerUpperBound(range, max, true);
+    found = true;
+  }
+
+  while ((match = comparisonPattern.exec(expression))) {
+    const left = match[1];
+    const operator = match[2];
+    const right = match[3];
+    const leftIsColumn = tokenMatchesColumn(left, columnName);
+    const rightIsColumn = tokenMatchesColumn(right, columnName);
+
+    if (leftIsColumn) {
+      const value = parseSqlNumberToken(right);
+
+      if (value !== null) {
+        applyIntegerComparison(range, operator, value);
+        found = true;
+      }
+      continue;
+    }
+
+    if (rightIsColumn) {
+      const value = parseSqlNumberToken(left);
+      const reversedOperator = reverseComparisonOperator(operator);
+
+      if (value !== null && reversedOperator) {
+        applyIntegerComparison(range, reversedOperator, value);
+        found = true;
+      }
+    }
+  }
+
+  if (!found) {
+    return null;
+  }
+
+  return {
+    ...(range.min !== null ? { min: range.min } : {}),
+    ...(range.max !== null ? { max: range.max } : {}),
+  };
+}
+
 function parseCheckAllowedValues(ddl = "", columns = []) {
   const allowedValuesByColumn = new Map();
   const expressions = extractCheckExpressions(ddl);
@@ -256,6 +418,42 @@ function parseCheckAllowedValues(ddl = "", columns = []) {
   return allowedValuesByColumn;
 }
 
+function parseCheckIntegerRanges(ddl = "", columns = []) {
+  const integerRangesByColumn = new Map();
+  const expressions = extractCheckExpressions(ddl);
+
+  columns
+    .filter((column) => column.affinity === "INTEGER")
+    .forEach((column) => {
+      const range = { min: null, max: null };
+
+      expressions.forEach((expression) => {
+        const expressionRange = findColumnIntegerRangeInExpression(expression, column.name);
+
+        if (!expressionRange) {
+          return;
+        }
+
+        if (Number.isSafeInteger(expressionRange.min)) {
+          range.min = range.min === null ? expressionRange.min : Math.max(range.min, expressionRange.min);
+        }
+
+        if (Number.isSafeInteger(expressionRange.max)) {
+          range.max = range.max === null ? expressionRange.max : Math.min(range.max, expressionRange.max);
+        }
+      });
+
+      if (range.min !== null || range.max !== null) {
+        integerRangesByColumn.set(column.name, {
+          ...(range.min !== null ? { min: range.min } : {}),
+          ...(range.max !== null ? { max: range.max } : {}),
+        });
+      }
+    });
+
+  return integerRangesByColumn;
+}
+
 function groupForeignKeys(rows) {
   const grouped = new Map();
 
@@ -336,11 +534,17 @@ function getTableDetail(db, tableName, options = {}) {
     .map((column) => normalizeColumn(column, visibleSet))
     .sort((left, right) => left.cid - right.cid);
   const allowedValuesByColumn = parseCheckAllowedValues(entry.sql, columns);
+  const integerRangesByColumn = parseCheckIntegerRanges(entry.sql, columns);
 
-  columns = columns.map((column) => ({
-    ...column,
-    allowedValues: allowedValuesByColumn.get(column.name) ?? [],
-  }));
+  columns = columns.map((column) => {
+    const integerRange = integerRangesByColumn.get(column.name);
+
+    return {
+      ...column,
+      allowedValues: allowedValuesByColumn.get(column.name) ?? [],
+      ...(integerRange ? { integerRange } : {}),
+    };
+  });
 
   const foreignKeys = groupForeignKeys(
     db.prepare(`PRAGMA foreign_key_list(${quoteIdentifier(tableName)})`).all()

package/server/services/sqlite/structureService.js

@@ -1,11 +1,13 @@
 const { getRawStructureEntries, getTableDetail } = require("./introspection");
 const { quoteIdentifier } = require("../../utils/identifier");
 const { serializeRows } = require("../../utils/sqliteTypes");
+const { TypeGenerationService } = require("../typeGenerationService");
 
 class StructureService {
   constructor({ connectionManager, appStateStore }) {
     this.connectionManager = connectionManager;
     this.appStateStore = appStateStore;
+    this.typeGenerationService = new TypeGenerationService();
   }
 
   getStructureOverview() {
@@ -79,6 +81,11 @@ class StructureService {
       notSafelyUpdatable: table.notSafelyUpdatable,
     };
   }
+
+  generateTableTypes(tableName, target, options = {}) {
+    const db = this.connectionManager.getActiveDatabase();
+    return this.typeGenerationService.generateTypesFromDatabase(db, tableName, target, options);
+  }
 }
 
 module.exports = {