sqlite-hub 0.4.0 → 0.6.0

package/frontend/styles/views.css

@@ -25,6 +25,36 @@
   gap: var(--spacing-8);
 }
 
+.table-designer-view {
+  display: flex;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.table-designer-workspace {
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  min-height: 0;
+  min-width: 0;
+}
+
+.table-designer-workspace__top,
+.table-designer-workspace__bottom {
+  min-height: 0;
+  min-width: 0;
+}
+
+.table-designer-workspace__top {
+  flex: 1;
+}
+
+.table-designer-workspace__bottom {
+  flex: 0 0 34%;
+}
+
 .landing-view {
   align-items: center;
   display: flex;
@@ -82,3 +112,13 @@
 .system-placeholder-card.is-primary {
   border-bottom-color: var(--color-primary-container);
 }
+
+@media (max-width: 1023px) {
+  .table-designer-view {
+    flex-direction: column;
+  }
+
+  .table-designer-workspace__bottom {
+    flex-basis: 280px;
+  }
+}

package/package.json

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

package/server/routes/data.js

@@ -26,6 +26,8 @@ function createDataRouter({ dataBrowserService }) {
       const data = dataBrowserService.getTableData(req.params.tableName, {
         limit: req.query.limit,
         offset: req.query.offset,
+        sortColumn: req.query.sortColumn,
+        sortDirection: req.query.sortDirection,
       });
 
       res.json(

package/server/routes/export.js

@@ -24,7 +24,10 @@ function createExportRouter({ exportService }) {
   router.post(
     "/table.csv",
     route((req, res) => {
-      const result = exportService.exportTable(req.body?.tableName);
+      const result = exportService.exportTable(req.body?.tableName, {
+        sortColumn: req.body?.sortColumn,
+        sortDirection: req.body?.sortDirection,
+      });
       sendCsv(res, result);
     })
   );

package/server/routes/overview.js

@@ -31,6 +31,18 @@ function createOverviewRouter({ overviewService }) {
     })
   );
 
+  router.post(
+    "/overview/open-in-finder",
+    route(async (req, res) => {
+      await overviewService.revealActiveDatabaseInFinder();
+      res.json(
+        successResponse({
+          message: "Database file revealed in Finder.",
+        })
+      );
+    })
+  );
+
   return router;
 }
 

package/server/routes/sql.js

@@ -1,7 +1,43 @@
 const express = require("express");
 const { route, successResponse } = require("../utils/errors");
 
-function createSqlRouter({ appStateStore, sqlExecutor }) {
+function parseBooleanFlag(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase();
+
+  return ["1", "true", "yes", "on"].includes(normalized);
+}
+
+function parseListLimit(value, fallback = 30, max = 100) {
+  const numericValue = Number(value);
+
+  if (!Number.isFinite(numericValue) || numericValue < 1) {
+    return fallback;
+  }
+
+  return Math.min(max, Math.round(numericValue));
+}
+
+function parseOffset(value) {
+  const numericValue = Number(value);
+
+  if (!Number.isFinite(numericValue) || numericValue < 0) {
+    return 0;
+  }
+
+  return Math.round(numericValue);
+}
+
+function getActiveDatabaseKey(connectionManager) {
+  return connectionManager.getActiveConnection()?.id ?? null;
+}
+
+function createSqlRouter({ appStateStore, connectionManager, sqlExecutor }) {
   const router = express.Router();
 
   router.post(
@@ -21,9 +57,32 @@ function createSqlRouter({ appStateStore, sqlExecutor }) {
   router.get(
     "/history",
     route((req, res) => {
+      const databaseKey = getActiveDatabaseKey(connectionManager);
+      const tab = String(req.query.tab ?? "recent").trim().toLowerCase();
+      const options = {
+        databaseKey,
+        limit: parseListLimit(req.query.limit, 30, 100),
+        offset: parseOffset(req.query.offset),
+        search: String(req.query.search ?? ""),
+        queryType: String(req.query.queryType ?? "").trim() || null,
+        onlySaved: parseBooleanFlag(req.query.onlySaved),
+        onlyFavorites: parseBooleanFlag(req.query.onlyFavorites),
+      };
+      const result =
+        tab === "failed"
+          ? appStateStore.getFailedQueries(options)
+          : appStateStore.getRecentQueries({
+              ...options,
+              onlySaved: tab === "saved" ? true : options.onlySaved,
+            });
+
       res.json(
         successResponse({
-          data: appStateStore.getSqlHistory(),
+          data: result,
+          metadata: {
+            databaseKey,
+            tab,
+          },
         })
       );
     })
@@ -32,11 +91,110 @@ function createSqlRouter({ appStateStore, sqlExecutor }) {
   router.delete(
     "/history",
     route((req, res) => {
-      appStateStore.clearSqlHistory();
+      const databaseKey = getActiveDatabaseKey(connectionManager);
+      const deletedCount = appStateStore.clearQueryHistoryForDatabase(databaseKey);
+
+      res.json(
+        successResponse({
+          message: deletedCount
+            ? "Query history cleared for the active database."
+            : "No query history was found for the active database.",
+          data: {
+            deletedCount,
+          },
+          metadata: {
+            databaseKey,
+          },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/history/:historyId/runs",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: appStateStore.getQueryRunsByHistoryId(
+            req.params.historyId,
+            parseListLimit(req.query.limit, 8, 50)
+          ),
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/history/:historyId/favorite",
+    route((req, res) => {
+      const nextValue = parseBooleanFlag(req.body?.value);
+      res.json(
+        successResponse({
+          message: nextValue ? "Query favorited." : "Query removed from favorites.",
+          data: appStateStore.toggleFavorite(req.params.historyId, nextValue),
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/history/:historyId/saved",
+    route((req, res) => {
+      const nextValue = parseBooleanFlag(req.body?.value);
+      res.json(
+        successResponse({
+          message: nextValue ? "Query saved." : "Query removed from saved queries.",
+          data: appStateStore.toggleSaved(req.params.historyId, nextValue),
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/history/:historyId/title",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          message: "Query title updated.",
+          data: appStateStore.renameQuery(req.params.historyId, req.body?.title),
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/history/:historyId/notes",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          message: "Query notes updated.",
+          data: appStateStore.updateQueryNotes(req.params.historyId, req.body?.notes),
+        })
+      );
+    })
+  );
+
+  router.delete(
+    "/history/:historyId",
+    route((req, res) => {
+      appStateStore.deleteQueryHistoryItem(req.params.historyId);
+      res.json(
+        successResponse({
+          message: "Query history item deleted.",
+          data: {
+            id: Number(req.params.historyId),
+          },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/history/:historyId",
+    route((req, res) => {
       res.json(
         successResponse({
-          message: "SQL history cleared.",
-          data: [],
+          data: appStateStore.getQueryHistoryItemById(req.params.historyId),
         })
       );
     })

package/server/routes/tableDesigner.js

@@ -0,0 +1,60 @@
+const express = require("express");
+const { route, successResponse } = require("../utils/errors");
+
+function createTableDesignerRouter({ tableDesignerService }) {
+  const router = express.Router();
+
+  router.get(
+    "/",
+    route((req, res) => {
+      const data = tableDesignerService.getOverview();
+
+      res.json(
+        successResponse({
+          data,
+          readOnly: false,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/:tableName",
+    route((req, res) => {
+      const data = tableDesignerService.getTableDraft(req.params.tableName);
+
+      res.json(
+        successResponse({
+          data,
+          readOnly: false,
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/save",
+    route((req, res) => {
+      const data = tableDesignerService.saveDraft(req.body ?? {});
+      const isCreate = String(req.body?.draft?.mode ?? req.body?.mode ?? "").trim() !== "edit";
+      const fillsImportedRows = Boolean(req.body?.draft?.fillImportedRows ?? req.body?.fillImportedRows);
+
+      res.json(
+        successResponse({
+          message: isCreate
+            ? fillsImportedRows
+              ? "Table created and filled from CSV."
+              : "Table created."
+            : "Table schema updated.",
+          data,
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createTableDesignerRouter,
+};

package/server/server.js

@@ -11,11 +11,13 @@ const { BackupService } = require("./services/sqlite/backupService");
 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 { createConnectionsRouter } = require("./routes/connections");
 const { createOverviewRouter } = require("./routes/overview");
 const { createSqlRouter } = require("./routes/sql");
 const { createStructureRouter } = require("./routes/structure");
 const { createDataRouter } = require("./routes/data");
+const { createTableDesignerRouter } = require("./routes/tableDesigner");
 const { createSettingsRouter } = require("./routes/settings");
 const { createExportRouter } = require("./routes/export");
 
@@ -46,6 +48,7 @@ const exportService = new ExportService({
 });
 const structureService = new StructureService({ connectionManager, appStateStore });
 const dataBrowserService = new DataBrowserService({ connectionManager });
+const tableDesignerService = new TableDesignerService({ connectionManager });
 
 connectionManager.initialize();
 
@@ -75,9 +78,10 @@ app.use(
   })
 );
 app.use("/api/db", createOverviewRouter({ overviewService }));
-app.use("/api/sql", createSqlRouter({ appStateStore, sqlExecutor }));
+app.use("/api/sql", createSqlRouter({ appStateStore, connectionManager, sqlExecutor }));
 app.use("/api/structure", createStructureRouter({ structureService }));
 app.use("/api/data", createDataRouter({ dataBrowserService }));
+app.use("/api/table-designer", createTableDesignerRouter({ tableDesignerService }));
 app.use("/api/settings", createSettingsRouter({ appStateStore }));
 app.use("/api/export", createExportRouter({ exportService }));
 

package/server/services/sqlite/dataBrowserService.js

@@ -6,6 +6,7 @@ const {
   serializeRows,
 } = require("../../utils/sqliteTypes");
 const { getRawStructureEntries, getTableDetail } = require("./introspection");
+const { buildTableOrderClause, normalizeTableSort } = require("./tableSort");
 
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 100;
@@ -70,9 +71,10 @@ class DataBrowserService {
     const db = this.connectionManager.getActiveDatabase();
     const tableDetail = getTableDetail(db, tableName);
     const { limit, offset } = normalizePaginationOptions(options);
+    const sort = normalizeTableSort(tableDetail, options);
     const selectExpression =
       tableDetail.identityStrategy?.type === "rowid" ? "rowid AS __rowid__, *" : "*";
-    const orderClause = this.buildOrderClause(tableDetail);
+    const orderClause = buildTableOrderClause(tableDetail, sort);
     const statement = db.prepare(
       [
         `SELECT ${selectExpression} FROM ${quoteIdentifier(tableName)}`,
@@ -114,6 +116,7 @@ class DataBrowserService {
       rows,
       identityStrategy: tableDetail.identityStrategy,
       notSafelyUpdatable: tableDetail.notSafelyUpdatable,
+      sort,
     };
   }
 
@@ -238,21 +241,6 @@ class DataBrowserService {
       `Table ${tableDetail.name} cannot be updated because it has no stable row identity.`
     );
   }
-
-  buildOrderClause(tableDetail) {
-    if (tableDetail.identityStrategy?.type === "rowid") {
-      return "rowid ASC";
-    }
-
-    if (tableDetail.identityStrategy?.type === "primaryKey") {
-      return tableDetail.identityStrategy.columns
-        .map((columnName) => `${quoteIdentifier(columnName)} ASC`)
-        .join(", ");
-    }
-
-    return "";
-  }
-
   getRowByIdentity(db, tableDetail, where) {
     const selectExpression =
       tableDetail.identityStrategy?.type === "rowid" ? "rowid AS __rowid__, *" : "*";

package/server/services/sqlite/exportService.js

@@ -2,6 +2,7 @@ const { quoteIdentifier } = require("../../utils/identifier");
 const { serializeRows } = require("../../utils/sqliteTypes");
 const { rowsToCsv } = require("../../utils/csv");
 const { getTableDetail } = require("./introspection");
+const { buildTableOrderClause, normalizeTableSort } = require("./tableSort");
 
 class ExportService {
   constructor({ appStateStore, connectionManager, sqlExecutor }) {
@@ -32,10 +33,11 @@ class ExportService {
     };
   }
 
-  exportTable(tableName) {
+  exportTable(tableName, options = {}) {
     const db = this.connectionManager.getActiveDatabase();
     const tableDetail = getTableDetail(db, tableName, { includeRowCount: false });
-    const orderClause = this.buildOrderClause(tableDetail);
+    const sort = normalizeTableSort(tableDetail, options);
+    const orderClause = buildTableOrderClause(tableDetail, sort);
     const statement = db.prepare(
       [
         `SELECT * FROM ${quoteIdentifier(tableName)}`,
@@ -58,20 +60,6 @@ class ExportService {
       rowCount: rows.length,
     };
   }
-
-  buildOrderClause(tableDetail) {
-    if (tableDetail.identityStrategy?.type === "rowid") {
-      return "rowid ASC";
-    }
-
-    if (tableDetail.identityStrategy?.type === "primaryKey") {
-      return tableDetail.identityStrategy.columns
-        .map((columnName) => `${quoteIdentifier(columnName)} ASC`)
-        .join(", ");
-    }
-
-    return "";
-  }
 }
 
 module.exports = {

package/server/services/sqlite/overviewService.js

@@ -1,5 +1,12 @@
+const fs = require("fs");
+const path = require("path");
+const { execFile } = require("child_process");
+const { promisify } = require("util");
+const { AppError, DatabaseRequiredError } = require("../../utils/errors");
 const { listSchema } = require("./introspection");
 
+const execFileAsync = promisify(execFile);
+
 class OverviewService {
   constructor({ connectionManager }) {
     this.connectionManager = connectionManager;
@@ -102,6 +109,33 @@ class OverviewService {
       readOnly: active?.readOnly ?? false,
     };
   }
+
+  async revealActiveDatabaseInFinder() {
+    const active = this.connectionManager.getActiveConnection();
+    const targetPath = active?.path;
+
+    if (!targetPath) {
+      throw new DatabaseRequiredError();
+    }
+
+    if (!fs.existsSync(targetPath)) {
+      throw new AppError("The active database file could not be found on disk.", 404, {
+        code: "DATABASE_FILE_NOT_FOUND",
+      });
+    }
+
+    if (process.platform === "darwin") {
+      await execFileAsync("open", ["-R", targetPath]);
+      return;
+    }
+
+    if (process.platform === "win32") {
+      await execFileAsync("explorer.exe", ["/select,", targetPath]);
+      return;
+    }
+
+    await execFileAsync("xdg-open", [path.dirname(targetPath)]);
+  }
 }
 
 module.exports = {