sqlite-hub 0.17.2 → 1.1.0

package/server/routes/externalApi.js

@@ -0,0 +1,304 @@
+const express = require("express");
+const { createApiTokenAuth } = require("../middleware/apiTokenAuth");
+const { readBearerToken } = require("../middleware/apiTokenAuth");
+const { AuthenticationError, ValidationError, route, successResponse } = require("../utils/errors");
+const { buildAppInfo } = require("../services/appInfoService");
+
+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 })
+  );
+
+  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

@@ -1,34 +1,43 @@
 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");
-
-function readAppVersion() {
-  const packageJsonPath = path.resolve(__dirname, "..", "..", "package.json");
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-  return packageJson.version ?? "0.0.0";
+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;
+
+  return {
+    activeDatabase,
+    apiTokens: activeDatabase && tokenService ? tokenService.listTokens(activeDatabase.id) : [],
+  };
 }
 
-function readSqliteVersion() {
-  const db = new Database(":memory:");
+function requireActiveDatabase(connectionManager) {
+  const activeDatabase = connectionManager?.getActiveConnection?.() ?? null;
 
-  try {
-    return db.prepare("SELECT sqlite_version() AS version").get().version ?? "unknown";
-  } finally {
-    db.close();
+  if (!activeDatabase) {
+    throw new DatabaseRequiredError("Select a database before managing API tokens.");
   }
+
+  return activeDatabase;
 }
 
-function readSettingsMetadata() {
+function buildSettingsMetadata(context) {
   return {
-    appVersion: readAppVersion(),
-    sqliteVersion: readSqliteVersion(),
+    ...readSettingsMetadata(),
+    ...getActiveTokenContext(context),
   };
 }
 
-function createSettingsRouter({ appStateStore }) {
+function createSettingsRouter({ appStateStore, connectionManager, tokenService, versionCheckService }) {
   const router = express.Router();
+  const context = { connectionManager, tokenService };
+  const checkVersion = versionCheckService ?? checkLatestAppVersion;
 
   router.get(
     "/",
@@ -36,7 +45,7 @@ function createSettingsRouter({ appStateStore }) {
       res.json(
         successResponse({
           data: appStateStore.getSettings(),
-          metadata: readSettingsMetadata(),
+          metadata: buildSettingsMetadata(context),
         })
       );
     })
@@ -50,7 +59,63 @@ function createSettingsRouter({ appStateStore }) {
         successResponse({
           message: "Settings updated.",
           data: settings,
-          metadata: readSettingsMetadata(),
+          metadata: buildSettingsMetadata(context),
+        })
+      );
+    })
+  );
+
+  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) => {
+      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 +126,10 @@ function createSettingsRouter({ appStateStore }) {
 
 module.exports = {
   createSettingsRouter,
+  buildSettingsMetadata,
+  checkLatestAppVersion,
+  compareSemver,
+  isNewerVersion,
   readSettingsMetadata,
   readSqliteVersion,
 };

package/server/server.js

@@ -21,6 +21,8 @@ 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");
@@ -32,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");
@@ -64,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();
 
@@ -116,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) => {
@@ -227,7 +246,9 @@ if (require.main === module) {
 module.exports = {
   app,
   appStateStore,
+  apiTokenService,
   connectionManager,
+  databaseCommandService,
   DEFAULT_HOST,
   DEFAULT_PORT,
   parsePortArgument,

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,
+};