sqlite-hub 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sqlite-hub",
-    "version": "0.7.0",
+    "version": "0.9.0",
     "description": "SQLite-only local management app backend and SPA shell",
     "main": "server/server.js",
     "bin": {

package/server/routes/charts.js

@@ -57,7 +57,10 @@ function createChartsRouter({ appStateStore, connectionManager, sqlExecutor }) {
     "/query-history/:historyId/execute",
     route((req, res) => {
       const databaseKey = requireActiveDatabaseKey(connectionManager);
-      const item = appStateStore.getQueryHistoryItemForDatabase(req.params.historyId, databaseKey);
+      const item = appStateStore.getChartQueryHistoryItemForDatabase(
+        req.params.historyId,
+        databaseKey
+      );
       const result = sqlExecutor.execute(item.rawSql, {
         persistHistory: false,
         requireReader: true,

package/server/routes/data.js

@@ -39,6 +39,20 @@ function createDataRouter({ dataBrowserService }) {
     })
   );
 
+  router.post(
+    "/:tableName/row",
+    route((req, res) => {
+      const data = dataBrowserService.getTableRow(req.params.tableName, req.body ?? {});
+
+      res.json(
+        successResponse({
+          data,
+          readOnly: false,
+        })
+      );
+    })
+  );
+
   router.patch(
     "/:tableName/rows",
     route((req, res) => {

package/server/routes/mediaTagging.js

@@ -0,0 +1,166 @@
+const fs = require("node:fs");
+const express = require("express");
+const { NotFoundError, route, successResponse } = require("../utils/errors");
+
+function createMediaTaggingRouter({ mediaTaggingService }) {
+  const router = express.Router();
+
+  router.get(
+    "/",
+    route((req, res) => {
+      const data = mediaTaggingService.getViewState();
+
+      res.json(
+        successResponse({
+          data,
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/preview",
+    route((req, res) => {
+      const data = mediaTaggingService.getViewState({
+        config: req.body?.config ?? {},
+        skippedMediaKeys: req.body?.skippedMediaKeys ?? [],
+      });
+
+      res.json(
+        successResponse({
+          data,
+          message: "Media tagging preview updated.",
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/config",
+    route((req, res) => {
+      const data = mediaTaggingService.saveConfig(req.body?.config ?? {}, {
+        skippedMediaKeys: req.body?.skippedMediaKeys ?? [],
+      });
+
+      res.json(
+        successResponse({
+          data,
+          message: "Media tagging configuration saved.",
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/tag-table/create",
+    route((req, res) => {
+      const data = mediaTaggingService.createDefaultTagTable(req.body ?? {});
+
+      res.json(
+        successResponse({
+          data,
+          message: "Tag table created.",
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/mapping-table/create",
+    route((req, res) => {
+      const data = mediaTaggingService.createDefaultMappingTable(req.body ?? {});
+
+      res.json(
+        successResponse({
+          data,
+          message: "Mapping table created.",
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/tags",
+    route((req, res) => {
+      const data = mediaTaggingService.createTag(req.body ?? {});
+
+      res.json(
+        successResponse({
+          data,
+          message: "Tag created.",
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/tags/delete",
+    route((req, res) => {
+      const data = mediaTaggingService.deleteTag(req.body ?? {});
+
+      res.json(
+        successResponse({
+          data,
+          message: "Tag removed.",
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/skip",
+    route((req, res) => {
+      const data = mediaTaggingService.skipCurrentMedia(req.body ?? {});
+
+      res.json(
+        successResponse({
+          data,
+          message: "Media item skipped and marked tagged.",
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/apply",
+    route((req, res) => {
+      const data = mediaTaggingService.applyTagging(req.body ?? {});
+
+      res.json(
+        successResponse({
+          data,
+          message: "Media item tagged.",
+          readOnly: Boolean(data.connection?.readOnly),
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/media-file",
+    route((req, res) => {
+      const rawPath = String(req.query.path ?? "").trim();
+      const resolvedPath = mediaTaggingService.resolveMediaFilePath(rawPath);
+
+      if (!resolvedPath || !fs.existsSync(resolvedPath)) {
+        throw new NotFoundError(`Media file not found: ${rawPath}`);
+      }
+
+      res.sendFile(resolvedPath);
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createMediaTaggingRouter,
+};

package/server/routes/sql.js

@@ -74,6 +74,7 @@ function createSqlRouter({ appStateStore, connectionManager, sqlExecutor }) {
           : appStateStore.getRecentQueries({
               ...options,
               onlySaved: tab === "saved" ? true : options.onlySaved,
+              onlyUnsaved: tab === "unsaved",
             });
 
       res.json(

package/server/server.js

@@ -12,6 +12,7 @@ const { ExportService } = require("./services/sqlite/exportService");
 const { StructureService } = require("./services/sqlite/structureService");
 const { DataBrowserService } = require("./services/sqlite/dataBrowserService");
 const { TableDesignerService } = require("./services/sqlite/tableDesignerService");
+const { MediaTaggingService } = require("./services/sqlite/mediaTaggingService");
 const { createConnectionsRouter } = require("./routes/connections");
 const { createOverviewRouter } = require("./routes/overview");
 const { createSqlRouter } = require("./routes/sql");
@@ -19,6 +20,7 @@ const { createChartsRouter } = require("./routes/charts");
 const { createStructureRouter } = require("./routes/structure");
 const { createDataRouter } = require("./routes/data");
 const { createTableDesignerRouter } = require("./routes/tableDesigner");
+const { createMediaTaggingRouter } = require("./routes/mediaTagging");
 const { createSettingsRouter } = require("./routes/settings");
 const { createExportRouter } = require("./routes/export");
 
@@ -50,6 +52,7 @@ const exportService = new ExportService({
 const structureService = new StructureService({ connectionManager, appStateStore });
 const dataBrowserService = new DataBrowserService({ connectionManager });
 const tableDesignerService = new TableDesignerService({ connectionManager });
+const mediaTaggingService = new MediaTaggingService({ connectionManager, appStateStore });
 
 connectionManager.initialize();
 
@@ -84,6 +87,7 @@ app.use("/api/charts", createChartsRouter({ appStateStore, connectionManager, sq
 app.use("/api/structure", createStructureRouter({ structureService }));
 app.use("/api/data", createDataRouter({ dataBrowserService }));
 app.use("/api/table-designer", createTableDesignerRouter({ tableDesignerService }));
+app.use("/api/media-tagging", createMediaTaggingRouter({ mediaTaggingService }));
 app.use("/api/settings", createSettingsRouter({ appStateStore }));
 app.use("/api/export", createExportRouter({ exportService }));
 

package/server/services/sqlite/dataBrowserService.js

@@ -113,6 +113,7 @@ class DataBrowserService {
       pageCount: Math.max(1, Math.ceil((tableDetail.rowCount ?? rows.length) / limit)),
       columns,
       columnMeta: tableDetail.columns,
+      foreignKeys: tableDetail.foreignKeys,
       rows,
       identityStrategy: tableDetail.identityStrategy,
       notSafelyUpdatable: tableDetail.notSafelyUpdatable,
@@ -120,6 +121,30 @@ class DataBrowserService {
     };
   }
 
+  getTableRow(tableName, payload = {}) {
+    const db = this.connectionManager.getActiveDatabase();
+    const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
+    const identity = payload.identity ?? null;
+
+    if (tableDetail.notSafelyUpdatable) {
+      throw new ValidationError(
+        `Table ${tableName} has no stable row identity, so a specific row cannot be targeted.`
+      );
+    }
+
+    const where = this.buildWhereClause(tableDetail, identity);
+    const row = this.getRowByIdentity(db, tableDetail, where);
+
+    if (!row) {
+      throw new NotFoundError(`Row not found in table: ${tableName}`);
+    }
+
+    return {
+      tableName,
+      row,
+    };
+  }
+
   updateTableRow(tableName, payload = {}) {
     this.connectionManager.assertWritable();
 

package/server/services/sqlite/exportService.js

@@ -3,6 +3,25 @@ const { serializeRows } = require("../../utils/sqliteTypes");
 const { rowsToCsv } = require("../../utils/csv");
 const { getTableDetail } = require("./introspection");
 const { buildTableOrderClause, normalizeTableSort } = require("./tableSort");
+const {
+  buildAutoTitle,
+  detectQueryType,
+  detectTables,
+} = require("../storage/queryHistoryUtils");
+
+function sanitizeFilenameBase(value, fallback = "query-results") {
+  const sanitized = String(value ?? "")
+    .replace(/[<>:"/\\|?*\u0000-\u001f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/[. ]+$/g, "");
+
+  if (!sanitized) {
+    return fallback;
+  }
+
+  return sanitized.slice(0, 120);
+}
 
 class ExportService {
   constructor({ appStateStore, connectionManager, sqlExecutor }) {
@@ -16,13 +35,24 @@ class ExportService {
   }
 
   exportQuery(sql) {
+    const activeConnection = this.connectionManager.getActiveConnection();
+    const historyItem = activeConnection
+      ? this.appStateStore.findQueryHistoryItemBySql(activeConnection.id, sql)
+      : null;
+    const filenameBase = sanitizeFilenameBase(
+      historyItem?.displayTitle ||
+        buildAutoTitle(sql, {
+          queryType: detectQueryType(sql),
+          tablesDetected: detectTables(sql),
+        })
+    );
     const result = this.sqlExecutor.execute(sql, {
       persistHistory: false,
       requireReader: true,
     });
 
     return {
-      filename: "query-results.csv",
+      filename: `${filenameBase}.csv`,
       csv: rowsToCsv({
         columns: result.columns,
         rows: result.rows,