sqlite-hub 1.0.0 → 1.1.1

package/frontend/styles/views.css

@@ -62,6 +62,30 @@
     min-width: 0;
 }
 
+.table-designer-workspace__toolbar {
+    align-items: center;
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--spacing-4);
+    justify-content: space-between;
+}
+
+.table-designer-workspace__toolbar-left,
+.table-designer-workspace__toolbar-right {
+    align-items: center;
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--spacing-2);
+}
+
+.table-designer-workspace__toolbar-right {
+    margin-left: auto;
+}
+
+.table-designer-workspace__file-input {
+    display: none;
+}
+
 .table-designer-workspace__top,
 .table-designer-workspace__bottom {
     min-height: 0;
@@ -152,18 +176,18 @@
 }
 
 .charts-view__sidebar {
-    background: var(--color-surface-low);
-    border-right: 1px solid var(--border-medium);
+    background: var(--color-surface-container-lowest);
+    border-left: 1px solid rgb(var(--rgb-outline) / 0.1);
     display: flex;
-    flex: 0 0 clamp(20rem, 28vw, 23rem);
+    flex: 0 0 clamp(20rem, 26vw, 22.5rem);
     flex-direction: column;
     min-height: 0;
-    width: clamp(20rem, 28vw, 23rem);
+    width: clamp(20rem, 26vw, 22.5rem);
 }
 
 .charts-view__sidebar-header {
-    border-bottom: 1px solid var(--border-medium);
-    padding: var(--spacing-5);
+    border-bottom: 1px solid rgb(var(--rgb-outline) / 0.1);
+    padding: var(--spacing-4);
 }
 
 .structure-view {
@@ -177,23 +201,10 @@
 .structure-view__sidebar {
     background: var(--color-surface-low);
     border-right: 1px solid var(--border-medium);
-    display: flex;
-    flex: 0 0 clamp(16rem, 22vw, 18.5rem);
-    flex-direction: column;
-    min-height: 0;
-    width: clamp(16rem, 22vw, 18.5rem);
 }
 
 .structure-view__sidebar-header {
-    border-bottom: 1px solid var(--border-medium);
-    padding: var(--spacing-5);
-}
-
-.structure-view__sidebar-body {
-    flex: 1;
-    min-height: 0;
-    overflow-y: auto;
-    padding: var(--spacing-4);
+    align-items: flex-start;
 }
 
 .structure-view__detail {
@@ -245,30 +256,30 @@
 .documents-view__sidebar {
     background: var(--color-surface-low);
     border-right: 1px solid var(--border-medium);
-    display: flex;
-    flex: 0 0 clamp(17rem, 23vw, 21rem);
-    flex-direction: column;
-    min-height: 100%;
+    max-width: var(--subnavi-width);
     overflow: hidden;
-    width: clamp(17rem, 23vw, 21rem);
 }
 
 .documents-view__sidebar-header {
     align-items: center;
-    border-bottom: 1px solid var(--border-medium);
-    display: flex;
-    justify-content: space-between;
-    padding: var(--spacing-5);
 }
 
-.documents-view__sidebar-body {
-    display: flex;
-    flex: 1;
-    flex-direction: column;
-    gap: var(--spacing-2);
+.data-view-grid {
+    display: grid;
+    grid-template-columns: 1fr;
+    height: 100%;
     min-height: 0;
-    overflow: hidden;
-    padding: var(--spacing-3);
+}
+
+.data-view__sidebar {
+    background: var(--color-surface-low);
+    border-right: 1px solid var(--border-medium);
+}
+
+@media (min-width: 768px) {
+    .data-view-grid--with-subnavi {
+        grid-template-columns: var(--subnavi-width) minmax(0, 1fr);
+    }
 }
 
 .documents-list-item {
@@ -351,11 +362,20 @@
     padding: var(--spacing-4);
 }
 
-.documents-filename-field {
+.documents-titlebar {
+    align-items: center;
     display: flex;
-    flex-direction: column;
+    flex-wrap: wrap;
+    gap: var(--spacing-2);
+    max-width: min(100%, 44rem);
     padding: var(--spacing-4);
     padding-bottom: 0;
+}
+
+.documents-filename-field {
+    display: flex;
+    flex: 1 1 22rem;
+    flex-direction: column;
     max-width: 32rem;
     min-width: min(100%, 14rem);
 }
@@ -386,6 +406,10 @@
     opacity: 1;
 }
 
+.documents-create-button {
+    flex: 0 0 auto;
+}
+
 .documents-toolbar__actions {
     display: flex;
     flex-wrap: wrap;
@@ -624,6 +648,7 @@
         border-bottom: 1px solid var(--border-medium);
         border-right: 0;
         flex: 0 0 auto;
+        max-width: none;
         max-height: 18rem;
         min-height: 18rem;
         width: 100%;
@@ -644,6 +669,11 @@
     margin-top: 1.5rem;
 }
 
+.structure-sidebar__section {
+    max-width: 100%;
+    width: min(var(--subnavi-item-width), 100%);
+}
+
 .charts-view__detail {
     display: flex;
     flex: 1;
@@ -652,6 +682,10 @@
     min-width: 0;
 }
 
+.charts-detail-scroll {
+    scrollbar-gutter: stable;
+}
+
 .charts-detail-shell {
     min-height: 100%;
     padding: var(--spacing-6);
@@ -1628,6 +1662,8 @@
     }
 
     .charts-view__sidebar {
+        border-left: 0;
+        border-top: 1px solid var(--border-medium);
         flex-basis: 18rem;
         width: 100%;
     }
@@ -1638,6 +1674,7 @@
 
     .structure-view__sidebar {
         flex-basis: 18rem;
+        max-width: none;
         width: 100%;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sqlite-hub",
-    "version": "1.0.0",
+    "version": "1.1.1",
     "description": "SQLite-only local management app backend and SPA shell",
     "main": "server/server.js",
     "bin": {
@@ -27,7 +27,8 @@
         "express-rate-limit": "^8.5.2",
         "helmet": "^8.2.0",
         "marked": "^18.0.5",
-        "material-symbols": "^0.45.1"
+        "material-symbols": "^0.45.1",
+        "parquetjs-lite": "^0.8.7"
     },
     "devDependencies": {
         "@tailwindcss/cli": "^4.3.1",

package/server/routes/export.js

@@ -1,9 +1,19 @@
 const express = require("express");
-const { route, successResponse } = require("../utils/errors");
+const { route, successResponse, ValidationError } = require("../utils/errors");
 
 function createExportRouter({ exportService }) {
   const router = express.Router();
 
+  function normalizeRequestFormat(format = "csv") {
+    return String(format ?? "csv").toLowerCase();
+  }
+
+  function assertJsonExportFormat(format) {
+    if (normalizeRequestFormat(format) === "parquet") {
+      throw new ValidationError("Parquet exports are binary and must use the download endpoint.");
+    }
+  }
+
   function sendExport(res, result) {
     res.setHeader("Content-Type", result.mimeType || "text/plain; charset=utf-8");
     res.setHeader(
@@ -13,13 +23,13 @@ function createExportRouter({ exportService }) {
     res.send(result.content ?? result.csv ?? "");
   }
 
-  function sendQueryExport(res, sql, format) {
-    const result = exportService.exportQuery(sql, { format });
+  async function sendQueryExport(res, sql, format) {
+    const result = await exportService.exportQueryDownload(sql, { format });
     sendExport(res, result);
   }
 
-  function exportTableFromBody(body, format) {
-    return exportService.exportTable(body?.tableName, {
+  async function exportTableFromBody(body, format) {
+    return exportService.exportTableDownload(body?.tableName, {
       sortColumn: body?.sortColumn,
       sortDirection: body?.sortDirection,
       filterColumn: body?.filterColumn,
@@ -29,13 +39,14 @@ function createExportRouter({ exportService }) {
     });
   }
 
-  function sendTableExport(res, body, format) {
-    sendExport(res, exportTableFromBody(body, format));
+  async function sendTableExport(res, body, format) {
+    sendExport(res, await exportTableFromBody(body, format));
   }
 
   router.post(
     "/query",
     route((req, res) => {
+      assertJsonExportFormat(req.body?.format);
       const result = exportService.exportQuery(req.body?.sql, {
         format: req.body?.format || "csv",
       });
@@ -57,29 +68,51 @@ function createExportRouter({ exportService }) {
 
   router.post(
     "/query.csv",
-    route((req, res) => {
-      sendQueryExport(res, req.body?.sql, "csv");
+    route(async (req, res) => {
+      await sendQueryExport(res, req.body?.sql, "csv");
     })
   );
 
   router.post(
     "/query.tsv",
-    route((req, res) => {
-      sendQueryExport(res, req.body?.sql, "tsv");
+    route(async (req, res) => {
+      await sendQueryExport(res, req.body?.sql, "tsv");
     })
   );
 
   router.post(
     "/query.md",
-    route((req, res) => {
-      sendQueryExport(res, req.body?.sql, "md");
+    route(async (req, res) => {
+      await sendQueryExport(res, req.body?.sql, "md");
+    })
+  );
+
+  router.post(
+    "/query.json",
+    route(async (req, res) => {
+      await sendQueryExport(res, req.body?.sql, "json");
+    })
+  );
+
+  router.post(
+    "/query.parquet",
+    route(async (req, res) => {
+      await sendQueryExport(res, req.body?.sql, "parquet");
     })
   );
 
   router.post(
     "/table",
     route((req, res) => {
-      const result = exportTableFromBody(req.body, req.body?.format || "csv");
+      assertJsonExportFormat(req.body?.format);
+      const result = exportService.exportTable(req.body?.tableName, {
+        sortColumn: req.body?.sortColumn,
+        sortDirection: req.body?.sortDirection,
+        filterColumn: req.body?.filterColumn,
+        filterOperator: req.body?.filterOperator,
+        filterValue: req.body?.filterValue,
+        format: req.body?.format || "csv",
+      });
 
       res.json(
         successResponse({
@@ -98,29 +131,63 @@ function createExportRouter({ exportService }) {
 
   router.post(
     "/table.csv",
-    route((req, res) => {
-      sendTableExport(res, req.body, "csv");
+    route(async (req, res) => {
+      await sendTableExport(res, req.body, "csv");
     })
   );
 
   router.post(
     "/table.tsv",
-    route((req, res) => {
-      sendTableExport(res, req.body, "tsv");
+    route(async (req, res) => {
+      await sendTableExport(res, req.body, "tsv");
     })
   );
 
   router.post(
     "/table.md",
-    route((req, res) => {
-      sendTableExport(res, req.body, "md");
+    route(async (req, res) => {
+      await sendTableExport(res, req.body, "md");
+    })
+  );
+
+  router.post(
+    "/table.json",
+    route(async (req, res) => {
+      await sendTableExport(res, req.body, "json");
+    })
+  );
+
+  router.post(
+    "/table.parquet",
+    route(async (req, res) => {
+      await sendTableExport(res, req.body, "parquet");
     })
   );
 
   router.get(
     "/table/:tableName.csv",
-    route((req, res) => {
-      const result = exportService.exportTable(req.params.tableName);
+    route(async (req, res) => {
+      const result = await exportService.exportTableDownload(req.params.tableName);
+      sendExport(res, result);
+    })
+  );
+
+  router.get(
+    "/table/:tableName.json",
+    route(async (req, res) => {
+      const result = await exportService.exportTableDownload(req.params.tableName, {
+        format: "json",
+      });
+      sendExport(res, result);
+    })
+  );
+
+  router.get(
+    "/table/:tableName.parquet",
+    route(async (req, res) => {
+      const result = await exportService.exportTableDownload(req.params.tableName, {
+        format: "parquet",
+      });
       sendExport(res, result);
     })
   );

package/server/routes/externalApi.js

@@ -1,10 +1,92 @@
 const express = require("express");
 const { createApiTokenAuth } = require("../middleware/apiTokenAuth");
-const { route, successResponse } = require("../utils/errors");
+const { readBearerToken } = require("../middleware/apiTokenAuth");
+const { AuthenticationError, ValidationError, route, successResponse } = require("../utils/errors");
+const { buildAppInfo } = require("../services/appInfoService");
 
-function createExternalApiRouter({ databaseService, tokenService }) {
+function buildRequestBaseUrl(req) {
+  const host = req.get("host") ?? `127.0.0.1:${req.socket.localPort ?? ""}`;
+  return `${req.protocol}://${host}`;
+}
+
+function readDatabaseId(req) {
+  return String(req.body?.databaseId ?? req.query.databaseId ?? "").trim();
+}
+
+function readSqlText(req) {
+  return String(req.body?.sql ?? req.body?.query ?? req.query.sql ?? req.query.query ?? "");
+}
+
+function readStoreName(req) {
+  return String(
+    req.body?.store ??
+      req.body?.storeName ??
+      req.body?.name ??
+      req.query.store ??
+      req.query.storeName ??
+      req.query.name ??
+      ""
+  ).trim();
+}
+
+function authenticateDatabaseRequest(req, tokenService, databaseId) {
+  const token = readBearerToken(req.get("authorization"));
+
+  if (!token) {
+    throw new AuthenticationError("Bearer API token is required.", {
+      code: "API_TOKEN_REQUIRED",
+    });
+  }
+
+  return tokenService.authenticate(databaseId, token);
+}
+
+function createExternalApiRouter({ databaseService, tokenService, appInfoService = buildAppInfo }) {
   const router = express.Router();
 
+  router.get(
+    "/info",
+    route(async (req, res) => {
+      const port = Number(req.socket.localPort);
+      const data = await appInfoService({
+        port: Number.isInteger(port) ? port : null,
+        url: buildRequestBaseUrl(req),
+      });
+
+      res.json(successResponse({ data }));
+    })
+  );
+
+  router.post(
+    "/query",
+    route((req, res) => {
+      const databaseId = readDatabaseId(req);
+      const sql = readSqlText(req);
+      const storeName = readStoreName(req);
+
+      if (!databaseId) {
+        throw new ValidationError("databaseId is required.");
+      }
+
+      authenticateDatabaseRequest(req, tokenService, databaseId);
+
+      const { result } = databaseService.executeRawQuery(databaseId, sql, { storeName });
+
+      res.json(
+        successResponse({
+          message: "SQL executed successfully.",
+          data: result,
+          metadata: {
+            databaseId,
+            stored: Boolean(result.storedQuery),
+          },
+          timingMs: result.timingMs,
+          readOnly: false,
+        })
+      );
+    })
+  );
+
   router.use(
     "/databases/:databaseId",
     createApiTokenAuth({ tokenService })

package/server/routes/settings.js

@@ -1,31 +1,12 @@
 const express = require("express");
-const Database = require("better-sqlite3");
-const fs = require("node:fs");
-const path = require("node:path");
-const { DatabaseRequiredError, route, successResponse } = require("../utils/errors");
-
-function readAppVersion() {
-  const packageJsonPath = path.resolve(__dirname, "..", "..", "package.json");
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-  return packageJson.version ?? "0.0.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(),
-  };
-}
+const { AppError, DatabaseRequiredError, route, successResponse } = require("../utils/errors");
+const {
+  checkLatestAppVersion,
+  compareSemver,
+  isNewerVersion,
+  readSettingsMetadata,
+  readSqliteVersion,
+} = require("../services/appInfoService");
 
 function getActiveTokenContext({ connectionManager, tokenService }) {
   const activeDatabase = connectionManager?.getActiveConnection?.() ?? null;
@@ -53,9 +34,10 @@ function buildSettingsMetadata(context) {
   };
 }
 
-function createSettingsRouter({ appStateStore, connectionManager, tokenService }) {
+function createSettingsRouter({ appStateStore, connectionManager, tokenService, versionCheckService }) {
   const router = express.Router();
   const context = { connectionManager, tokenService };
+  const checkVersion = versionCheckService ?? checkLatestAppVersion;
 
   router.get(
     "/",
@@ -83,6 +65,30 @@ function createSettingsRouter({ appStateStore, connectionManager, tokenService }
     })
   );
 
+  router.get(
+    "/version-check",
+    route(async (req, res) => {
+      try {
+        const result = await checkVersion();
+
+        res.json(
+          successResponse({
+            data: result,
+            metadata: readSettingsMetadata(),
+          })
+        );
+      } catch (error) {
+        throw new AppError("Version check failed. Check your internet connection and try again.", 502, {
+          code: "VERSION_CHECK_FAILED",
+          details: {
+            source: "npm",
+            message: error.message,
+          },
+        });
+      }
+    })
+  );
+
   router.post(
     "/api-tokens",
     route((req, res) => {
@@ -121,6 +127,9 @@ function createSettingsRouter({ appStateStore, connectionManager, tokenService }
 module.exports = {
   createSettingsRouter,
   buildSettingsMetadata,
+  checkLatestAppVersion,
+  compareSemver,
+  isNewerVersion,
   readSettingsMetadata,
   readSqliteVersion,
 };