sqlite-hub 1.2.0 → 1.5.0

package/package.json

@@ -1,12 +1,26 @@
 {
     "name": "sqlite-hub",
-    "version": "1.2.0",
+    "version": "1.5.0",
     "description": "SQLite-only local management app backend and SPA shell",
     "license": "MIT",
     "main": "server/server.js",
     "bin": {
         "sqlite-hub": "bin/sqlite-hub.js"
     },
+    "files": [
+        "bin/",
+        "docs/",
+        "examples/",
+        "frontend/",
+        "server/data/.gitkeep",
+        "server/data/db_logos/.gitkeep",
+        "server/middleware/",
+        "server/routes/",
+        "server/server.js",
+        "server/services/",
+        "server/utils/",
+        "tailwind.config.cjs"
+    ],
     "scripts": {
         "build": "npm run build:css",
         "build:css": "tailwindcss -i ./frontend/styles/tailwind.css -o ./frontend/styles/tailwind.generated.css --minify",
@@ -15,7 +29,9 @@
         "start": "node bin/sqlite-hub.js",
         "dev": "node --watch server/server.js --port:4180",
         "prepack": "npm run build:css",
-        "publish": "bash scripts/publish_brew.sh && sleep 10 && npm login --auth-type=web && bash scripts/publish_npm.sh"
+        "publish": "bash scripts/publish_brew.sh && sleep 10 && bash scripts/publish_npm.sh",
+        "screenshots": "node scripts/screenshot_sqlite_hub.js --width:1920 --height:1280",
+        "screenshots:backup-drawer": "node scripts/screenshot_backup_drawer.js"
     },
     "dependencies": {
         "better-sqlite3": "^12.10.1",

package/server/routes/backups.js

@@ -27,6 +27,19 @@ function createBackupsRouter({ backupService }) {
     })
   );
 
+  router.get(
+    "/:backupId/diff",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: backupService.diffBackupWithCurrent(req.params.backupId, {
+            sampleLimit: req.query.sampleLimit,
+          }),
+        })
+      );
+    })
+  );
+
   router.post(
     "/",
     route(async (req, res) => {
@@ -49,11 +62,14 @@ function createBackupsRouter({ backupService }) {
   router.patch(
     "/:backupId",
     route((req, res) => {
-      const backup = backupService.updateBackupNotes(req.params.backupId, req.body?.notes ?? "");
+      const backup = backupService.updateBackupDetails(req.params.backupId, {
+        name: req.body?.name,
+        notes: req.body?.notes,
+      });
 
       res.json(
         successResponse({
-          message: "Backup notes updated.",
+          message: "Backup updated.",
           data: backup,
         })
       );

package/server/routes/data.js

@@ -20,6 +20,21 @@ function createDataRouter({ dataBrowserService }) {
     })
   );
 
+  router.get(
+    "/:tableName/advisor",
+    route((req, res) => {
+      const data = dataBrowserService.analyzeTable(req.params.tableName);
+
+      res.json(
+        successResponse({
+          message: "Table analysis complete.",
+          data,
+          readOnly: true,
+        })
+      );
+    })
+  );
+
   router.get(
     "/:tableName",
     route((req, res) => {
@@ -56,6 +71,36 @@ function createDataRouter({ dataBrowserService }) {
     })
   );
 
+  router.post(
+    "/:tableName/generate/preview",
+    route((req, res) => {
+      const data = dataBrowserService.previewSyntheticRows(req.params.tableName, req.body ?? {});
+
+      res.json(
+        successResponse({
+          message: "Synthetic data preview generated.",
+          data,
+          readOnly: false,
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/:tableName/generate/insert",
+    route((req, res) => {
+      const data = dataBrowserService.insertSyntheticRows(req.params.tableName, req.body ?? {});
+
+      res.json(
+        successResponse({
+          message: `Generated ${data.insertedRowCount} rows for ${data.tableName}.`,
+          data,
+          readOnly: false,
+        })
+      );
+    })
+  );
+
   router.patch(
     "/:tableName/rows",
     route((req, res) => {

package/server/routes/externalApi.js

@@ -29,6 +29,232 @@ function readStoreName(req) {
   ).trim();
 }
 
+function decodePathPart(value = "") {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function readPathParts(req) {
+  return String(req.path ?? "")
+    .split("/")
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map(decodePathPart);
+}
+
+function buildExternalApiAccessDescriptor(req) {
+  const method = String(req.method ?? "GET").toUpperCase();
+  const parts = readPathParts(req);
+
+  if (parts[0] === "info") {
+    return {
+      action: "api.info.get",
+      targetType: "app",
+      targetName: "info",
+    };
+  }
+
+  if (parts[0] === "query") {
+    return {
+      action: "api.query.execute",
+      databaseKey: readDatabaseId(req),
+      targetType: "query",
+      targetName: readStoreName(req) || "raw query",
+    };
+  }
+
+  if (parts[0] !== "databases") {
+    return {
+      action: `api.${method.toLowerCase()}`,
+      targetType: "request",
+      targetName: req.path,
+    };
+  }
+
+  const databaseKey = parts[1] ?? "";
+  const collection = parts[2] ?? "";
+  const itemName = parts[3] ?? "";
+  const subAction = parts[4] ?? "";
+
+  if (!collection) {
+    return {
+      action: "api.database.get",
+      databaseKey,
+      targetType: "database",
+      targetName: databaseKey,
+    };
+  }
+
+  if (collection === "tables") {
+    if (!itemName) {
+      return {
+        action: "api.tables.list",
+        databaseKey,
+        targetType: "database",
+        targetName: databaseKey,
+      };
+    }
+
+    if (subAction === "row") {
+      return {
+        action: "api.table.row.export",
+        databaseKey,
+        targetType: "table",
+        targetName: itemName,
+      };
+    }
+
+    if (subAction === "types") {
+      return {
+        action: "api.table.types.generate",
+        databaseKey,
+        targetType: "table",
+        targetName: itemName,
+      };
+    }
+
+    return {
+      action: "api.table.get",
+      databaseKey,
+      targetType: "table",
+      targetName: itemName,
+    };
+  }
+
+  if (collection === "backups") {
+    return {
+      action: method === "GET" ? "api.backups.list" : "api.backup.create",
+      databaseKey,
+      targetType: "database",
+      targetName: databaseKey,
+    };
+  }
+
+  if (collection === "queries") {
+    if (!itemName) {
+      return {
+        action: "api.queries.list",
+        databaseKey,
+        targetType: "database",
+        targetName: databaseKey,
+      };
+    }
+
+    if (subAction === "execute") {
+      return {
+        action: "api.query.execute.saved",
+        databaseKey,
+        targetType: "query",
+        targetName: itemName,
+      };
+    }
+
+    if (subAction === "export") {
+      return {
+        action: "api.query.export",
+        databaseKey,
+        targetType: "query",
+        targetName: itemName,
+      };
+    }
+
+    if (subAction === "notes") {
+      return {
+        action: "api.query.notes.get",
+        databaseKey,
+        targetType: "query",
+        targetName: itemName,
+      };
+    }
+
+    return {
+      action: "api.query.get",
+      databaseKey,
+      targetType: "query",
+      targetName: itemName,
+    };
+  }
+
+  if (collection === "documents") {
+    if (!itemName) {
+      return {
+        action: "api.documents.list",
+        databaseKey,
+        targetType: "database",
+        targetName: databaseKey,
+      };
+    }
+
+    if (subAction === "export") {
+      return {
+        action: "api.document.export",
+        databaseKey,
+        targetType: "document",
+        targetName: itemName,
+      };
+    }
+
+    return {
+      action: "api.document.get",
+      databaseKey,
+      targetType: "document",
+      targetName: itemName,
+    };
+  }
+
+  return {
+    action: `api.${collection}.${method.toLowerCase()}`,
+    databaseKey,
+    targetType: collection,
+    targetName: itemName || databaseKey,
+  };
+}
+
+function createExternalApiAccessLogger(appStateStore) {
+  return (req, res, next) => {
+    const startedAtMs = Date.now();
+    const startedAt = new Date(startedAtMs).toISOString();
+
+    res.on("finish", () => {
+      if (!appStateStore?.recordAccessLog) {
+        return;
+      }
+
+      const descriptor = buildExternalApiAccessDescriptor(req);
+      const failed = res.statusCode >= 400;
+
+      try {
+        appStateStore.recordAccessLog({
+          source: "api",
+          action: descriptor.action,
+          databaseKey: descriptor.databaseKey,
+          targetType: descriptor.targetType,
+          targetName: descriptor.targetName,
+          status: failed ? "error" : "success",
+          startedAt,
+          durationMs: Date.now() - startedAtMs,
+          errorMessage: failed ? req.accessLogError || `HTTP ${res.statusCode}` : null,
+          metadata: {
+            method: req.method,
+            path: req.path,
+            route: req.route?.path ? String(req.route.path) : null,
+            statusCode: res.statusCode,
+            apiTokenId: req.apiToken?.id ?? null,
+            apiTokenName: req.apiToken?.name ?? null,
+          },
+        });
+      } catch {
+        // Access logging must not change API behavior.
+      }
+    });
+
+    next();
+  };
+}
+
 function authenticateDatabaseRequest(req, tokenService, databaseId) {
   const token = readBearerToken(req.get("authorization"));
 
@@ -38,12 +264,24 @@ function authenticateDatabaseRequest(req, tokenService, databaseId) {
     });
   }
 
-  return tokenService.authenticate(databaseId, token);
+  const apiToken = tokenService.authenticate(databaseId, token);
+
+  req.apiToken = apiToken;
+  return apiToken;
 }
 
-function createExternalApiRouter({ databaseService, tokenService, appInfoService = buildAppInfo }) {
+function createExternalApiRouter({
+  databaseService,
+  tokenService,
+  appStateStore = null,
+  appInfoService = buildAppInfo,
+}) {
   const router = express.Router();
 
+  if (appStateStore?.recordAccessLog) {
+    router.use(createExternalApiAccessLogger(appStateStore));
+  }
+
   router.get(
     "/info",
     route(async (req, res) => {
@@ -131,6 +369,46 @@ function createExternalApiRouter({ databaseService, tokenService, appInfoService
     })
   );
 
+  router.get(
+    "/databases/:databaseId/backups",
+    route((req, res) => {
+      const backups = databaseService.listBackups(req.params.databaseId);
+
+      res.json(
+        successResponse({
+          data: {
+            items: backups,
+          },
+          metadata: {
+            databaseId: req.params.databaseId,
+            total: backups.length,
+          },
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/databases/:databaseId/backups",
+    route(async (req, res) => {
+      const backup = await databaseService.createBackup(req.params.databaseId, {
+        name: req.body?.name,
+        notes: req.body?.notes,
+        context: req.body?.context ?? "api",
+      });
+
+      res.json(
+        successResponse({
+          message: "Backup created and verified.",
+          data: backup,
+          metadata: {
+            databaseId: req.params.databaseId,
+          },
+        })
+      );
+    })
+  );
+
   router.post(
     "/databases/:databaseId/tables/:tableName/row",
     route((req, res) => {
@@ -154,6 +432,42 @@ function createExternalApiRouter({ databaseService, tokenService, appInfoService
     })
   );
 
+  router.post(
+    "/databases/:databaseId/tables/:tableName/types",
+    route((req, res) => {
+      const target = String(req.body?.target ?? "").trim();
+
+      if (!["typescript", "rust", "kotlin", "swift"].includes(target)) {
+        throw new ValidationError(
+          `Unsupported type target "${req.body?.target}". Supported targets: typescript, rust, kotlin, swift.`,
+          { code: "INVALID_TYPE_TARGET" }
+        );
+      }
+
+      const result = databaseService.generateTableTypes(
+        req.params.databaseId,
+        req.params.tableName,
+        target,
+        req.body?.options ?? {}
+      );
+      const { warnings, metadata, ...data } = result;
+
+      res.json(
+        successResponse({
+          message: "Types generated.",
+          data,
+          metadata: {
+            databaseId: req.params.databaseId,
+            tableName: req.params.tableName,
+            ...metadata,
+          },
+          warnings,
+          readOnly: true,
+        })
+      );
+    })
+  );
+
   router.get(
     "/databases/:databaseId/queries",
     route((req, res) => {
@@ -300,6 +614,11 @@ function createExternalApiRouter({ databaseService, tokenService, appInfoService
     })
   );
 
+  router.use((error, req, res, next) => {
+    req.accessLogError = error?.message ?? null;
+    next(error);
+  });
+
   return router;
 }
 

package/server/routes/logs.js

@@ -0,0 +1,127 @@
+const express = require("express");
+const { DatabaseRequiredError, route, successResponse } = require("../utils/errors");
+
+const RANGE_MS = {
+  "1h": 60 * 60 * 1000,
+  "24h": 24 * 60 * 60 * 1000,
+  "7d": 7 * 24 * 60 * 60 * 1000,
+  "30d": 30 * 24 * 60 * 60 * 1000,
+};
+
+function normalizeOption(value, allowedValues, fallback = "all") {
+  const normalized = String(value ?? fallback).trim().toLowerCase();
+  return allowedValues.includes(normalized) ? normalized : fallback;
+}
+
+function parseLimit(value) {
+  const numeric = Number(value);
+  return Number.isInteger(numeric) && numeric > 0 ? Math.min(numeric, 200) : 100;
+}
+
+function parseOffset(value) {
+  const numeric = Number(value);
+  return Number.isInteger(numeric) && numeric >= 0 ? numeric : 0;
+}
+
+function normalizeTimestamp(value) {
+  const normalized = String(value ?? "").trim();
+
+  if (!normalized) {
+    return null;
+  }
+
+  const timestamp = new Date(normalized).getTime();
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
+}
+
+function resolveTimeWindow(query = {}, now = new Date()) {
+  const explicitFrom = normalizeTimestamp(query.from);
+  const explicitTo = normalizeTimestamp(query.to);
+  const range = normalizeOption(query.range, ["1h", "24h", "7d", "30d", "all"], "all");
+
+  if (explicitFrom || explicitTo) {
+    return {
+      range,
+      from: explicitFrom,
+      to: explicitTo,
+    };
+  }
+
+  if (range === "all") {
+    return {
+      range,
+      from: null,
+      to: null,
+    };
+  }
+
+  return {
+    range,
+    from: new Date(now.getTime() - RANGE_MS[range]).toISOString(),
+    to: now.toISOString(),
+  };
+}
+
+function resolveActiveDatabase(connectionManager) {
+  const activeDatabase = connectionManager.getActiveConnection() ?? null;
+
+  if (!activeDatabase?.id) {
+    throw new DatabaseRequiredError();
+  }
+
+  return activeDatabase;
+}
+
+function createLogsRouter({ appStateStore, connectionManager, now = () => new Date() }) {
+  const router = express.Router();
+
+  router.get(
+    "/",
+    route((req, res) => {
+      const timeWindow = resolveTimeWindow(req.query, now());
+      const activeDatabase = resolveActiveDatabase(connectionManager);
+      const kind = normalizeOption(req.query.kind, ["all", "query", "access"], "all");
+      const actor = normalizeOption(req.query.actor, ["all", "user", "cli", "api", "mcp"], "all");
+      const status = normalizeOption(req.query.status, ["all", "success", "error"], "all");
+      const queryType = normalizeOption(
+        req.query.queryType,
+        ["all", "select", "insert", "update", "delete", "pragma", "create", "alter", "drop", "other"],
+        "all"
+      );
+      const destructive = normalizeOption(req.query.destructive, ["all", "yes", "no"], "all");
+      const search = String(req.query.search ?? "").trim();
+      const result = appStateStore.listActivityLogs({
+        kind,
+        actor: actor === "all" ? null : actor,
+        status: status === "all" ? null : status,
+        databaseKey: activeDatabase.id,
+        queryType: queryType === "all" ? null : queryType,
+        destructive,
+        from: timeWindow.from,
+        to: timeWindow.to,
+        search,
+        limit: parseLimit(req.query.limit),
+        offset: parseOffset(req.query.offset),
+      });
+
+      res.json(
+        successResponse({
+          data: result,
+          metadata: {
+            ...result.filters,
+            range: timeWindow.range,
+            activeDatabase,
+          },
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createLogsRouter,
+  resolveActiveDatabase,
+  resolveTimeWindow,
+};

package/server/routes/structure.js

@@ -30,6 +30,28 @@ function createStructureRouter({ structureService }) {
     })
   );
 
+  router.post(
+    "/:tableName/types",
+    route((req, res) => {
+      const result = structureService.generateTableTypes(
+        req.params.tableName,
+        req.body?.target,
+        req.body?.options ?? {}
+      );
+      const { warnings, metadata, ...data } = result;
+
+      res.json(
+        successResponse({
+          message: "Types generated.",
+          data,
+          metadata,
+          warnings,
+          readOnly: true,
+        })
+      );
+    })
+  );
+
   return router;
 }
 

package/server/server.js

@@ -36,6 +36,7 @@ const { createSettingsRouter } = require("./routes/settings");
 const { createExportRouter } = require("./routes/export");
 const { createDocumentsRouter } = require("./routes/documents");
 const { createExternalApiRouter } = require("./routes/externalApi");
+const { createLogsRouter } = require("./routes/logs");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const FRONTEND_ROOT = path.join(PACKAGE_ROOT, "frontend");
@@ -133,11 +134,13 @@ app.use(
 );
 app.use("/api/export", createExportRouter({ exportService }));
 app.use("/api/documents", createDocumentsRouter({ appStateStore, connectionManager }));
+app.use("/api/logs", createLogsRouter({ appStateStore, connectionManager }));
 app.use(
   "/api/v1",
   createExternalApiRouter({
     databaseService: databaseCommandService,
     tokenService: apiTokenService,
+    appStateStore,
   })
 );