sqlite-hub 0.17.0 → 1.0.0

package/server/routes/externalApi.js

@@ -0,0 +1,222 @@
+const express = require("express");
+const { createApiTokenAuth } = require("../middleware/apiTokenAuth");
+const { route, successResponse } = require("../utils/errors");
+
+function createExternalApiRouter({ databaseService, tokenService }) {
+  const router = express.Router();
+
+  router.use(
+    "/databases/:databaseId",
+    createApiTokenAuth({ tokenService })
+  );
+
+  router.get(
+    "/databases/:databaseId",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: databaseService.getDatabase(req.params.databaseId),
+          metadata: { databaseId: req.params.databaseId },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/tables",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: { items: databaseService.listTables(req.params.databaseId) },
+          metadata: { databaseId: req.params.databaseId },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/tables/:tableName",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: databaseService.getTable(req.params.databaseId, req.params.tableName),
+          metadata: { databaseId: req.params.databaseId },
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/databases/:databaseId/tables/:tableName/row",
+    route((req, res) => {
+      const result = databaseService.getTableRow(
+        req.params.databaseId,
+        req.params.tableName,
+        req.body?.key
+      );
+
+      res.json(
+        successResponse({
+          data: result.data,
+          metadata: {
+            databaseId: req.params.databaseId,
+            filename: result.filename,
+            identity: result.identity,
+            tableName: result.table.name,
+          },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/queries",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: databaseService.listSavedQueries(req.params.databaseId),
+          metadata: { databaseId: req.params.databaseId },
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/databases/:databaseId/queries/:queryName/execute",
+    route((req, res) => {
+      const { query, result } = databaseService.executeSavedQuery(
+        req.params.databaseId,
+        req.params.queryName
+      );
+
+      res.json(
+        successResponse({
+          message: "Saved query executed successfully.",
+          data: result,
+          metadata: {
+            databaseId: req.params.databaseId,
+            query,
+          },
+          timingMs: result.timingMs,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/queries/:queryName/export",
+    route((req, res) => {
+      const { query, result } = databaseService.exportSavedQuery(
+        req.params.databaseId,
+        req.params.queryName,
+        req.query.format || "csv"
+      );
+
+      res.json(
+        successResponse({
+          data: {
+            filename: result.filename,
+            content: result.content ?? result.csv ?? "",
+            format: result.format,
+            mimeType: result.mimeType,
+            columns: result.columns,
+            rowCount: result.rowCount,
+          },
+          metadata: {
+            databaseId: req.params.databaseId,
+            query,
+          },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/queries/:queryName/notes",
+    route((req, res) => {
+      const query = databaseService.getSavedQuery(
+        req.params.databaseId,
+        req.params.queryName
+      );
+
+      res.json(
+        successResponse({
+          data: { notes: String(query.notes ?? "") },
+          metadata: { databaseId: req.params.databaseId, query },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/queries/:queryName",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: databaseService.getSavedQuery(
+            req.params.databaseId,
+            req.params.queryName
+          ),
+          metadata: { databaseId: req.params.databaseId },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/documents",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: { items: databaseService.listDocuments(req.params.databaseId) },
+          metadata: { databaseId: req.params.databaseId },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/documents/:documentName/export",
+    route((req, res) => {
+      const result = databaseService.exportDocument(
+        req.params.databaseId,
+        req.params.documentName
+      );
+
+      res.json(
+        successResponse({
+          data: {
+            filename: result.filename,
+            content: result.content,
+            mimeType: result.mimeType,
+          },
+          metadata: {
+            databaseId: req.params.databaseId,
+            document: result.document,
+          },
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/databases/:databaseId/documents/:documentName",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: databaseService.getDocument(
+            req.params.databaseId,
+            req.params.documentName
+          ),
+          metadata: { databaseId: req.params.databaseId },
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createExternalApiRouter,
+};

package/server/routes/settings.js

@@ -2,7 +2,7 @@ const express = require("express");
 const Database = require("better-sqlite3");
 const fs = require("node:fs");
 const path = require("node:path");
-const { route, successResponse } = require("../utils/errors");
+const { DatabaseRequiredError, route, successResponse } = require("../utils/errors");
 
 function readAppVersion() {
   const packageJsonPath = path.resolve(__dirname, "..", "..", "package.json");
@@ -27,8 +27,35 @@ function readSettingsMetadata() {
   };
 }
 
-function createSettingsRouter({ appStateStore }) {
+function getActiveTokenContext({ connectionManager, tokenService }) {
+  const activeDatabase = connectionManager?.getActiveConnection?.() ?? null;
+
+  return {
+    activeDatabase,
+    apiTokens: activeDatabase && tokenService ? tokenService.listTokens(activeDatabase.id) : [],
+  };
+}
+
+function requireActiveDatabase(connectionManager) {
+  const activeDatabase = connectionManager?.getActiveConnection?.() ?? null;
+
+  if (!activeDatabase) {
+    throw new DatabaseRequiredError("Select a database before managing API tokens.");
+  }
+
+  return activeDatabase;
+}
+
+function buildSettingsMetadata(context) {
+  return {
+    ...readSettingsMetadata(),
+    ...getActiveTokenContext(context),
+  };
+}
+
+function createSettingsRouter({ appStateStore, connectionManager, tokenService }) {
   const router = express.Router();
+  const context = { connectionManager, tokenService };
 
   router.get(
     "/",
@@ -36,7 +63,7 @@ function createSettingsRouter({ appStateStore }) {
       res.json(
         successResponse({
           data: appStateStore.getSettings(),
-          metadata: readSettingsMetadata(),
+          metadata: buildSettingsMetadata(context),
         })
       );
     })
@@ -50,7 +77,39 @@ function createSettingsRouter({ appStateStore }) {
         successResponse({
           message: "Settings updated.",
           data: settings,
-          metadata: readSettingsMetadata(),
+          metadata: buildSettingsMetadata(context),
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/api-tokens",
+    route((req, res) => {
+      const activeDatabase = requireActiveDatabase(connectionManager);
+      const token = tokenService.createToken(activeDatabase.id, req.body?.name);
+
+      res.status(201).json(
+        successResponse({
+          message: "API token created. It will only be shown once.",
+          data: token,
+          metadata: buildSettingsMetadata(context),
+        })
+      );
+    })
+  );
+
+  router.delete(
+    "/api-tokens/:tokenId",
+    route((req, res) => {
+      const activeDatabase = requireActiveDatabase(connectionManager);
+      const result = tokenService.deleteToken(activeDatabase.id, req.params.tokenId);
+
+      res.json(
+        successResponse({
+          message: "API token deleted.",
+          data: result,
+          metadata: buildSettingsMetadata(context),
         })
       );
     })
@@ -61,6 +120,7 @@ function createSettingsRouter({ appStateStore }) {
 
 module.exports = {
   createSettingsRouter,
+  buildSettingsMetadata,
   readSettingsMetadata,
   readSqliteVersion,
 };

package/server/server.js

@@ -3,6 +3,11 @@ const helmet = require("helmet");
 const rateLimit = require("express-rate-limit");
 const path = require("node:path");
 const { errorMiddleware } = require("./utils/errors");
+const {
+  LOOPBACK_HOST,
+  listenOnLoopback,
+  localRequestSecurity,
+} = require("./middleware/localRequestSecurity");
 const { resolveAppStatePaths } = require("./utils/appPaths");
 const { AppStateStore } = require("./services/storage/appStateStore");
 const { ConnectionManager } = require("./services/sqlite/connectionManager");
@@ -10,11 +15,14 @@ const { OverviewService } = require("./services/sqlite/overviewService");
 const { SqlExecutor } = require("./services/sqlite/sqlExecutor");
 const { ImportService } = require("./services/sqlite/importService");
 const { BackupService } = require("./services/sqlite/backupService");
+const { NativeFileDialogService } = require("./services/nativeFileDialogService");
 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 { ApiTokenService } = require("./services/apiTokenService");
+const { DatabaseCommandService } = require("./services/databaseCommandService");
 const { createConnectionsRouter } = require("./routes/connections");
 const { createOverviewRouter } = require("./routes/overview");
 const { createSqlRouter } = require("./routes/sql");
@@ -26,6 +34,7 @@ const { createMediaTaggingRouter } = require("./routes/mediaTagging");
 const { createSettingsRouter } = require("./routes/settings");
 const { createExportRouter } = require("./routes/export");
 const { createDocumentsRouter } = require("./routes/documents");
+const { createExternalApiRouter } = require("./routes/externalApi");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const FRONTEND_ROOT = path.join(PACKAGE_ROOT, "frontend");
@@ -37,6 +46,7 @@ const {
   legacyDatabasePaths: LEGACY_DATABASE_PATHS,
 } = resolveAppStatePaths(PACKAGE_ROOT);
 const DEFAULT_PORT = 4173;
+const DEFAULT_HOST = LOOPBACK_HOST;
 
 const appStateStore = new AppStateStore(APP_STATE_DB_PATH, {
   legacyFilePath: LEGACY_STATE_PATH,
@@ -47,6 +57,7 @@ const overviewService = new OverviewService({ connectionManager });
 const sqlExecutor = new SqlExecutor({ connectionManager, appStateStore });
 const importService = new ImportService({ connectionManager });
 const backupService = new BackupService({ connectionManager });
+const nativeFileDialogService = new NativeFileDialogService();
 const exportService = new ExportService({
   appStateStore,
   connectionManager,
@@ -56,6 +67,8 @@ const structureService = new StructureService({ connectionManager, appStateStore
 const dataBrowserService = new DataBrowserService({ connectionManager });
 const tableDesignerService = new TableDesignerService({ connectionManager });
 const mediaTaggingService = new MediaTaggingService({ connectionManager, appStateStore });
+const apiTokenService = new ApiTokenService({ appStateStore });
+const databaseCommandService = new DatabaseCommandService({ appStateStore });
 
 connectionManager.initialize();
 
@@ -66,6 +79,7 @@ app.use(
     contentSecurityPolicy: false,
   })
 );
+app.use("/api", localRequestSecurity);
 app.use(
   "/api",
   rateLimit({
@@ -97,6 +111,7 @@ app.use(
     connectionManager,
     importService,
     backupService,
+    nativeFileDialogService,
   })
 );
 app.use("/api/db", createOverviewRouter({ overviewService }));
@@ -106,9 +121,23 @@ 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/settings",
+  createSettingsRouter({
+    appStateStore,
+    connectionManager,
+    tokenService: apiTokenService,
+  })
+);
 app.use("/api/export", createExportRouter({ exportService }));
 app.use("/api/documents", createDocumentsRouter({ appStateStore, connectionManager }));
+app.use(
+  "/api/v1",
+  createExternalApiRouter({
+    databaseService: databaseCommandService,
+    tokenService: apiTokenService,
+  })
+);
 
 // auth: public favicon response; it exposes no application data.
 app.get("/favicon.ico", (req, res) => {
@@ -191,7 +220,7 @@ function startServer({ port } = {}) {
   const resolvedPort = resolvePort(port);
 
   return new Promise((resolve, reject) => {
-    const server = app.listen(resolvedPort);
+    const server = listenOnLoopback(app, resolvedPort);
 
     server.once("error", reject);
     server.once("listening", () => {
@@ -217,7 +246,10 @@ if (require.main === module) {
 module.exports = {
   app,
   appStateStore,
+  apiTokenService,
   connectionManager,
+  databaseCommandService,
+  DEFAULT_HOST,
   DEFAULT_PORT,
   parsePortArgument,
   resolvePort,

package/server/services/apiTokenService.js

@@ -0,0 +1,101 @@
+const crypto = require("node:crypto");
+const { AuthenticationError, NotFoundError, ValidationError } = require("../utils/errors");
+
+const TOKEN_PREFIX = "shub_";
+
+function hashApiToken(token) {
+  return crypto.createHash("sha256").update(String(token ?? ""), "utf8").digest("hex");
+}
+
+function normalizeDatabaseKey(databaseKey) {
+  const normalized = String(databaseKey ?? "").trim();
+
+  if (!normalized) {
+    throw new ValidationError("Database key is required.");
+  }
+
+  return normalized;
+}
+
+function normalizeTokenName(name) {
+  const normalized = String(name ?? "").trim() || "API token";
+
+  if (normalized.length > 80) {
+    throw new ValidationError("Token name must not exceed 80 characters.");
+  }
+
+  return normalized;
+}
+
+class ApiTokenService {
+  constructor({ appStateStore }) {
+    this.appStateStore = appStateStore;
+  }
+
+  assertDatabaseExists(databaseKey) {
+    const normalizedDatabaseKey = normalizeDatabaseKey(databaseKey);
+    const connection = this.appStateStore
+      .getRecentConnections()
+      .find((candidate) => candidate.id === normalizedDatabaseKey);
+
+    if (!connection) {
+      throw new NotFoundError(`Database not found: ${normalizedDatabaseKey}`);
+    }
+
+    return connection;
+  }
+
+  listTokens(databaseKey) {
+    const connection = this.assertDatabaseExists(databaseKey);
+    return this.appStateStore.listApiTokens(connection.id);
+  }
+
+  createToken(databaseKey, name) {
+    const connection = this.assertDatabaseExists(databaseKey);
+    const token = `${TOKEN_PREFIX}${crypto.randomBytes(32).toString("base64url")}`;
+    const record = this.appStateStore.createApiToken({
+      databaseKey: connection.id,
+      name: normalizeTokenName(name),
+      tokenHash: hashApiToken(token),
+      tokenPrefix: token.slice(0, 13),
+    });
+
+    return {
+      ...record,
+      token,
+    };
+  }
+
+  deleteToken(databaseKey, tokenId) {
+    const connection = this.assertDatabaseExists(databaseKey);
+    return this.appStateStore.deleteApiToken(connection.id, tokenId);
+  }
+
+  authenticate(databaseKey, token) {
+    const normalizedDatabaseKey = normalizeDatabaseKey(databaseKey);
+    const normalizedToken = String(token ?? "").trim();
+
+    if (!normalizedToken) {
+      throw new AuthenticationError("API token is required.", {
+        code: "API_TOKEN_REQUIRED",
+      });
+    }
+
+    const record = this.appStateStore.findApiTokenByHash(hashApiToken(normalizedToken));
+
+    if (!record || record.databaseKey !== normalizedDatabaseKey) {
+      throw new AuthenticationError("API token is invalid for this database.", {
+        code: "API_TOKEN_INVALID",
+      });
+    }
+
+    this.appStateStore.touchApiToken(record.id);
+    return record;
+  }
+}
+
+module.exports = {
+  ApiTokenService,
+  TOKEN_PREFIX,
+  hashApiToken,
+};