sqlite-hub 0.17.2 → 1.1.0

package/server/services/appInfoService.js

@@ -0,0 +1,215 @@
+const Database = require("better-sqlite3");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const VERSION_CHECK_TIMEOUT_MS = 5000;
+
+function readPackageMetadata() {
+  const packageJsonPath = path.resolve(__dirname, "..", "..", "package.json");
+  return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+}
+
+function readAppVersion() {
+  const packageJson = readPackageMetadata();
+  return packageJson.version ?? "0.0.0";
+}
+
+function readPackageName() {
+  const packageJson = readPackageMetadata();
+  return packageJson.name ?? "sqlite-hub";
+}
+
+function parseSemver(value) {
+  const match = String(value ?? "")
+    .trim()
+    .replace(/^v/i, "")
+    .match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?/);
+
+  if (!match) {
+    return null;
+  }
+
+  return {
+    major: Number(match[1] ?? 0),
+    minor: Number(match[2] ?? 0),
+    patch: Number(match[3] ?? 0),
+    prerelease: match[4] ?? "",
+  };
+}
+
+function compareSemver(left, right) {
+  const leftVersion = parseSemver(left);
+  const rightVersion = parseSemver(right);
+
+  if (!leftVersion || !rightVersion) {
+    return 0;
+  }
+
+  for (const key of ["major", "minor", "patch"]) {
+    if (leftVersion[key] > rightVersion[key]) {
+      return 1;
+    }
+
+    if (leftVersion[key] < rightVersion[key]) {
+      return -1;
+    }
+  }
+
+  if (leftVersion.prerelease && !rightVersion.prerelease) {
+    return -1;
+  }
+
+  if (!leftVersion.prerelease && rightVersion.prerelease) {
+    return 1;
+  }
+
+  return leftVersion.prerelease.localeCompare(rightVersion.prerelease);
+}
+
+function isNewerVersion(candidateVersion, currentVersion) {
+  return compareSemver(candidateVersion, currentVersion) > 0;
+}
+
+function readSqliteVersion() {
+  const db = new Database(":memory:");
+
+  try {
+    return db.prepare("SELECT sqlite_version() AS version").get().version ?? "unknown";
+  } finally {
+    db.close();
+  }
+}
+
+function readSettingsMetadata() {
+  return {
+    appVersion: readAppVersion(),
+    sqliteVersion: readSqliteVersion(),
+  };
+}
+
+async function fetchJsonWithTimeout(url, options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+
+  if (typeof fetchImpl !== "function") {
+    throw new Error("Fetch API is not available in this runtime.");
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? VERSION_CHECK_TIMEOUT_MS);
+
+  try {
+    const response = await fetchImpl(url, {
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "SQLite Hub version check",
+      },
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Registry responded with HTTP ${response.status}.`);
+    }
+
+    return response.json();
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function checkLatestAppVersion(options = {}) {
+  const packageName = options.packageName ?? readPackageName();
+  const currentVersion = options.currentVersion ?? readAppVersion();
+  const registryUrl =
+    options.registryUrl ??
+    `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+  const payload = await fetchJsonWithTimeout(registryUrl, options);
+  const latestVersion = String(payload?.version ?? "").trim();
+
+  if (!latestVersion) {
+    throw new Error("Registry response did not include a version.");
+  }
+
+  return {
+    packageName,
+    currentVersion,
+    latestVersion,
+    updateAvailable: isNewerVersion(latestVersion, currentVersion),
+    checkedAt: new Date().toISOString(),
+    source: "npm",
+    releaseUrl: `https://www.npmjs.com/package/${packageName}/v/${latestVersion}`,
+  };
+}
+
+function normalizeVersionCheckStatus(versionCheck) {
+  if (!versionCheck || versionCheck.status === "unknown") {
+    return versionCheck ?? null;
+  }
+
+  if (
+    versionCheck.currentVersion &&
+    versionCheck.latestVersion &&
+    compareSemver(versionCheck.currentVersion, versionCheck.latestVersion) > 0
+  ) {
+    return {
+      ...versionCheck,
+      status: "ahead",
+    };
+  }
+
+  return {
+    ...versionCheck,
+    status: versionCheck.updateAvailable ? "update_available" : "current",
+  };
+}
+
+async function buildAppInfo(options = {}) {
+  const packageName = options.packageName ?? readPackageName();
+  const appVersion = options.currentVersion ?? readAppVersion();
+  const sqliteVersion = options.sqliteVersion ?? readSqliteVersion();
+  let versionCheck = null;
+
+  try {
+    versionCheck = await (options.versionCheckService ?? checkLatestAppVersion)({
+      ...options,
+      packageName,
+      currentVersion: appVersion,
+    });
+    versionCheck = normalizeVersionCheckStatus(versionCheck);
+  } catch (error) {
+    versionCheck = {
+      packageName,
+      currentVersion: appVersion,
+      latestVersion: null,
+      updateAvailable: null,
+      checkedAt: new Date().toISOString(),
+      source: "npm",
+      releaseUrl: null,
+      status: "unknown",
+      error: {
+        message: error.message,
+      },
+    };
+  }
+
+  return {
+    packageName,
+    appVersion,
+    sqliteVersion,
+    port: options.port ?? null,
+    url: options.url ?? null,
+    versionCheck,
+  };
+}
+
+module.exports = {
+  VERSION_CHECK_TIMEOUT_MS,
+  buildAppInfo,
+  checkLatestAppVersion,
+  compareSemver,
+  isNewerVersion,
+  readAppVersion,
+  readPackageMetadata,
+  readPackageName,
+  readSettingsMetadata,
+  readSqliteVersion,
+};

package/server/services/databaseCommandService.js

@@ -0,0 +1,443 @@
+const path = require("node:path");
+const { NotFoundError, ReadOnlyError, ValidationError } = require("../utils/errors");
+const { ConnectionManager } = require("./sqlite/connectionManager");
+const { DataBrowserService } = require("./sqlite/dataBrowserService");
+const { ExportService } = require("./sqlite/exportService");
+const { getTableDetail } = require("./sqlite/introspection");
+const { SqlExecutor } = require("./sqlite/sqlExecutor");
+
+function normalizeLookupValue(value, label) {
+  const normalized = String(value ?? "").trim();
+
+  if (!normalized) {
+    throw new ValidationError(`${label} is required.`);
+  }
+
+  return normalized;
+}
+
+function normalizeOptionalValue(value) {
+  const normalized = String(value ?? "").trim();
+  return normalized || null;
+}
+
+function getQueryTitle(item) {
+  return item?.title || item?.displayTitle || item?.previewSql || item?.rawSql || "(untitled query)";
+}
+
+function getDocumentTitle(document) {
+  return document?.filename || document?.title || document?.id || "(untitled document)";
+}
+
+function sanitizeFilenameBase(value, fallback = "export") {
+  const sanitized = String(value ?? "")
+    .replace(/[<>:"/\\|?*\u0000-\u001f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/[. ]+$/g, "");
+
+  return (sanitized || fallback).slice(0, 120);
+}
+
+function normalizeMarkdownExportFilename(filename, fallback = "document.md") {
+  let normalizedFilename = String(filename ?? "")
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .replace(/[<>:"/\\|?*]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/^\.+/, "")
+    .replace(/[. ]+$/g, "");
+
+  if (!normalizedFilename) {
+    normalizedFilename = fallback;
+  }
+
+  if (!/\.md$/i.test(normalizedFilename)) {
+    normalizedFilename = `${normalizedFilename}.md`;
+  }
+
+  if (normalizedFilename.length > 160) {
+    normalizedFilename = `${normalizedFilename.slice(0, 157)}.md`;
+  }
+
+  return normalizedFilename;
+}
+
+function coerceIdentityValue(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 parseCompositePrimaryKeyValue(rawValue) {
+  if (rawValue && typeof rawValue === "object" && !Array.isArray(rawValue)) {
+    return rawValue;
+  }
+
+  try {
+    const parsed = JSON.parse(rawValue);
+
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch (error) {
+    // Fall through to the validation error below.
+  }
+
+  throw new ValidationError(
+    'Composite primary key export requires a JSON object, for example {"id":1,"locale":"en"}.'
+  );
+}
+
+function buildIdentityFromExportTarget(tableDetail, exportTarget) {
+  if (tableDetail.identityStrategy?.type === "rowid") {
+    const numberValue = Number(exportTarget);
+
+    return {
+      kind: "rowid",
+      values: {
+        rowid: Number.isInteger(numberValue) ? numberValue : exportTarget,
+      },
+    };
+  }
+
+  if (tableDetail.identityStrategy?.type === "primaryKey") {
+    const columns = tableDetail.identityStrategy.columns ?? [];
+
+    if (columns.length === 1) {
+      const columnName = columns[0];
+      const column = tableDetail.columns.find((candidate) => candidate.name === columnName);
+
+      return {
+        kind: "primaryKey",
+        columns,
+        values: {
+          [columnName]: coerceIdentityValue(column, exportTarget),
+        },
+      };
+    }
+
+    const parsed = parseCompositePrimaryKeyValue(exportTarget);
+
+    return {
+      kind: "primaryKey",
+      columns,
+      values: Object.fromEntries(
+        columns.map((columnName) => {
+          if (!Object.prototype.hasOwnProperty.call(parsed, columnName)) {
+            throw new ValidationError(`Missing primary key value for ${columnName}.`);
+          }
+
+          const column = tableDetail.columns.find((candidate) => candidate.name === columnName);
+          return [columnName, coerceIdentityValue(column, parsed[columnName])];
+        })
+      ),
+    };
+  }
+
+  throw new ValidationError(`Table ${tableDetail.name} has no stable row identity.`);
+}
+
+function buildRowJsonObject({ row, columns = [] } = {}) {
+  const names = columns
+    .map((column) => String(typeof column === "object" ? column?.name : column ?? "").trim())
+    .filter((name) => name && name !== "__identity");
+  const sourceNames = names.length
+    ? names
+    : Object.keys(row ?? {}).filter((name) => name !== "__identity");
+
+  return Object.fromEntries(
+    sourceNames
+      .map((name) => [name, Object.prototype.hasOwnProperty.call(row ?? {}, name) ? row[name] : undefined])
+      .filter(([, value]) => value !== undefined)
+  );
+}
+
+class DatabaseCommandService {
+  constructor({ appStateStore, runtimeFactory } = {}) {
+    this.appStateStore = appStateStore;
+    this.runtimeFactory = runtimeFactory ?? ((connection, options) => this.createRuntime(connection, options));
+  }
+
+  listDatabases() {
+    return this.appStateStore.getRecentConnections();
+  }
+
+  getDatabase(databaseReference) {
+    const normalizedReference = normalizeLookupValue(databaseReference, "Database").toLowerCase();
+    const connection = this.listDatabases().find(
+      (candidate) =>
+        String(candidate.label ?? "").toLowerCase() === normalizedReference ||
+        String(candidate.id ?? "").toLowerCase() === normalizedReference
+    );
+
+    if (!connection) {
+      throw new NotFoundError(`Database not found: ${databaseReference}`);
+    }
+
+    return connection;
+  }
+
+  createRuntime(connection, { readOnly = true } = {}) {
+    const connectionManager = new ConnectionManager({ appStateStore: this.appStateStore });
+
+    connectionManager.openConnection({
+      filePath: connection.path,
+      label: connection.label,
+      id: connection.id,
+      logoPath: connection.logoPath ?? null,
+      makeActive: false,
+      readOnly,
+    });
+
+    const sqlExecutor = new SqlExecutor({
+      connectionManager,
+      appStateStore: this.appStateStore,
+    });
+
+    return {
+      connectionManager,
+      dataBrowserService: new DataBrowserService({ connectionManager }),
+      db: connectionManager.getActiveDatabase(),
+      exportService: new ExportService({
+        appStateStore: this.appStateStore,
+        connectionManager,
+        sqlExecutor,
+      }),
+      sqlExecutor,
+      close() {
+        connectionManager.closeCurrent();
+      },
+    };
+  }
+
+  createReadOnlyRuntime(connection) {
+    return this.createRuntime(connection, { readOnly: true });
+  }
+
+  createWritableRuntime(connection) {
+    return this.createRuntime(connection, { readOnly: false });
+  }
+
+  withDatabase(databaseReference, callback, options = {}) {
+    const connection = this.getDatabase(databaseReference);
+    const runtime = this.runtimeFactory(connection, options);
+
+    try {
+      return callback({ connection, runtime });
+    } finally {
+      runtime.close?.();
+    }
+  }
+
+  listTables(databaseReference) {
+    return this.withDatabase(databaseReference, ({ runtime }) => runtime.dataBrowserService.listTables());
+  }
+
+  getTable(databaseReference, tableName) {
+    const normalizedTableName = normalizeLookupValue(tableName, "Table name");
+    return this.withDatabase(databaseReference, ({ runtime }) =>
+      getTableDetail(runtime.db, normalizedTableName)
+    );
+  }
+
+  getTableRow(databaseReference, tableName, exportTarget) {
+    const normalizedTableName = normalizeLookupValue(tableName, "Table name");
+    normalizeLookupValue(exportTarget, "Row key");
+
+    return this.withDatabase(databaseReference, ({ runtime }) => {
+      const tableDetail = getTableDetail(runtime.db, normalizedTableName, {
+        includeRowCount: false,
+      });
+      const identity = buildIdentityFromExportTarget(tableDetail, exportTarget);
+      const { row } = runtime.dataBrowserService.getTableRow(normalizedTableName, { identity });
+      const data = buildRowJsonObject({
+        row,
+        columns: tableDetail.columns.filter((column) => column.visible),
+      });
+
+      return {
+        data,
+        filename: `${sanitizeFilenameBase(
+          `${normalizedTableName}-${typeof exportTarget === "object" ? JSON.stringify(exportTarget) : exportTarget}`,
+          `${normalizedTableName}-row`
+        )}.json`,
+        identity,
+        table: tableDetail,
+      };
+    });
+  }
+
+  findQuery(databaseReference, queryName) {
+    const connection = this.getDatabase(databaseReference);
+    const normalizedQueryName = normalizeLookupValue(queryName, "Query name").toLowerCase();
+    const collection = this.appStateStore.buildQueryHistoryCollection({
+      databaseKey: connection.id,
+      search: queryName,
+      onlySaved: false,
+      limit: 100,
+    });
+
+    return (
+      collection.items.find((item) =>
+        [item.id, item.title, item.displayTitle]
+          .filter(Boolean)
+          .some((candidate) => String(candidate).toLowerCase() === normalizedQueryName)
+      ) ??
+      collection.items.find((item) =>
+        String(item.rawSql ?? "").toLowerCase().includes(normalizedQueryName)
+      ) ??
+      null
+    );
+  }
+
+  requireQuery(databaseReference, queryName) {
+    const query = this.findQuery(databaseReference, queryName);
+
+    if (!query) {
+      const available = this.listSavedQueries(databaseReference).items.map(getQueryTitle);
+      throw new NotFoundError(`Saved query not found: ${queryName}`, {
+        details: { available },
+      });
+    }
+
+    return query;
+  }
+
+  listSavedQueries(databaseReference, limit = 100) {
+    const connection = this.getDatabase(databaseReference);
+    return this.appStateStore.buildQueryHistoryCollection({
+      databaseKey: connection.id,
+      onlySaved: true,
+      limit,
+    });
+  }
+
+  getSavedQuery(databaseReference, queryName) {
+    return this.requireQuery(databaseReference, queryName);
+  }
+
+  executeSavedQuery(databaseReference, queryName) {
+    const query = this.requireQuery(databaseReference, queryName);
+    const result = this.withDatabase(databaseReference, ({ runtime }) =>
+      runtime.sqlExecutor.execute(query.rawSql, { persistHistory: false })
+    );
+
+    return { query, result };
+  }
+
+  executeRawQuery(databaseReference, sql, options = {}) {
+    const connection = this.getDatabase(databaseReference);
+    const { name = null, storeName = null, ...executeOptions } = options;
+    const normalizedStoreName = normalizeOptionalValue(storeName ?? name);
+
+    if (connection.readOnly) {
+      throw new ReadOnlyError(`Cannot execute raw SQL against a read-only database: ${connection.label}`);
+    }
+
+    const result = this.withDatabase(
+      connection.id,
+      ({ runtime }) => runtime.sqlExecutor.execute(sql, executeOptions),
+      { readOnly: false }
+    );
+    let storedQuery = null;
+
+    if (normalizedStoreName && result.historyId) {
+      this.appStateStore.renameQuery(result.historyId, normalizedStoreName, connection.id);
+      storedQuery = this.appStateStore.toggleSaved(result.historyId, true, connection.id);
+    }
+
+    return {
+      connection,
+      result: {
+        ...result,
+        storedQuery,
+      },
+      storedQuery,
+    };
+  }
+
+  exportSavedQuery(databaseReference, queryName, format = "csv") {
+    const query = this.requireQuery(databaseReference, queryName);
+    const result = this.withDatabase(databaseReference, ({ runtime }) =>
+      runtime.exportService.exportQuery(query.rawSql, { format })
+    );
+
+    return { query, result };
+  }
+
+  listDocuments(databaseReference) {
+    const connection = this.getDatabase(databaseReference);
+    return this.appStateStore.listDatabaseDocuments(connection.id);
+  }
+
+  findDocument(databaseReference, documentName) {
+    const connection = this.getDatabase(databaseReference);
+    const normalizedDocumentName = normalizeLookupValue(documentName, "Document name").toLowerCase();
+    const documents = this.appStateStore.listDatabaseDocuments(connection.id);
+    const exactMatch = documents.find((document) =>
+      [document.id, document.filename, document.title]
+        .filter(Boolean)
+        .some((candidate) => String(candidate).toLowerCase() === normalizedDocumentName)
+    );
+    const partialMatch = exactMatch ?? documents.find((document) =>
+      [document.filename, document.title]
+        .filter(Boolean)
+        .some((candidate) => String(candidate).toLowerCase().includes(normalizedDocumentName))
+    );
+
+    return partialMatch
+      ? this.appStateStore.getDatabaseDocument(connection.id, partialMatch.id)
+      : null;
+  }
+
+  requireDocument(databaseReference, documentName) {
+    const document = this.findDocument(databaseReference, documentName);
+
+    if (!document) {
+      const available = this.listDocuments(databaseReference).map(getDocumentTitle);
+      throw new NotFoundError(`Document not found: ${documentName}`, {
+        details: { available },
+      });
+    }
+
+    return document;
+  }
+
+  getDocument(databaseReference, documentName) {
+    return this.requireDocument(databaseReference, documentName);
+  }
+
+  exportDocument(databaseReference, documentName) {
+    const document = this.requireDocument(databaseReference, documentName);
+
+    return {
+      document,
+      content: document.content ?? "",
+      filename: normalizeMarkdownExportFilename(
+        document.filename,
+        `${document.title || path.basename(String(documentName)) || "document"}.md`
+      ),
+      mimeType: "text/markdown; charset=utf-8",
+    };
+  }
+}
+
+module.exports = {
+  DatabaseCommandService,
+  buildIdentityFromExportTarget,
+  buildRowJsonObject,
+  getDocumentTitle,
+  getQueryTitle,
+  normalizeMarkdownExportFilename,
+  sanitizeFilenameBase,
+};