sqlite-hub 0.1.3

package/server/routes/connections.js

@@ -0,0 +1,146 @@
+const express = require("express");
+const { route, successResponse } = require("../utils/errors");
+
+function createConnectionsRouter({ connectionManager, importService }) {
+  const router = express.Router();
+
+  router.post(
+    "/open",
+    route((req, res) => {
+      const connection = connectionManager.openConnection({
+        filePath: req.body.path,
+        label: req.body.label,
+        readOnly: Boolean(req.body.readOnly),
+        makeActive: true,
+      });
+
+      res.json(
+        successResponse({
+          message: "SQLite database opened successfully.",
+          data: connection,
+          readOnly: connection.readOnly,
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/create",
+    route((req, res) => {
+      const connection = connectionManager.createConnection({
+        filePath: req.body.path,
+        label: req.body.label,
+      });
+
+      res.json(
+        successResponse({
+          message: "SQLite database created successfully.",
+          data: connection,
+          readOnly: connection.readOnly,
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/import-sql",
+    route((req, res) => {
+      const result = importService.importSql({
+        sqlFilePath: req.body.sqlFilePath,
+        targetPath: req.body.targetPath,
+        targetConnectionId: req.body.targetConnectionId,
+        createNew: Boolean(req.body.createNew),
+        label: req.body.label,
+      });
+
+      res.json(
+        successResponse({
+          message: "SQL dump imported successfully.",
+          data: result,
+          metadata: {
+            importedInto: result.importedInto.id,
+          },
+          warnings: result.warnings,
+          timingMs: result.timingMs,
+          readOnly: result.importedInto.readOnly,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/recent",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: connectionManager.listRecentConnections(),
+        })
+      );
+    })
+  );
+
+  router.delete(
+    "/recent/:id",
+    route((req, res) => {
+      const recentConnections = connectionManager.removeRecentConnection(req.params.id);
+      res.json(
+        successResponse({
+          message: "Recent connection removed.",
+          data: recentConnections,
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/recent/:id",
+    route((req, res) => {
+      const connection = connectionManager.updateRecentConnection(req.params.id, {
+        filePath: req.body.path,
+        label: req.body.label,
+        readOnly: Boolean(req.body.readOnly),
+      });
+
+      res.json(
+        successResponse({
+          message: "Recent connection updated.",
+          data: connection,
+          readOnly: connection.readOnly,
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/select-active",
+    route((req, res) => {
+      const connection = connectionManager.selectActiveConnection(req.body.id);
+      res.json(
+        successResponse({
+          message: "Active SQLite database changed.",
+          data: connection,
+          readOnly: connection.readOnly,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/active",
+    route((req, res) => {
+      const active = connectionManager.getActiveConnection();
+      res.json(
+        successResponse({
+          data: active,
+          readOnly: active?.readOnly,
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createConnectionsRouter,
+};

package/server/routes/data.js

@@ -0,0 +1,59 @@
+const express = require("express");
+const { route, successResponse } = require("../utils/errors");
+
+function createDataRouter({ dataBrowserService }) {
+  const router = express.Router();
+
+  router.get(
+    "/",
+    route((req, res) => {
+      const tables = dataBrowserService.listTables();
+
+      res.json(
+        successResponse({
+          data: {
+            tables,
+          },
+          readOnly: false,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/:tableName",
+    route((req, res) => {
+      const data = dataBrowserService.getTableData(req.params.tableName, {
+        limit: req.query.limit,
+        offset: req.query.offset,
+      });
+
+      res.json(
+        successResponse({
+          data,
+          readOnly: data.notSafelyUpdatable,
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/:tableName/rows",
+    route((req, res) => {
+      const data = dataBrowserService.updateTableRow(req.params.tableName, req.body ?? {});
+
+      res.json(
+        successResponse({
+          message: "Table row updated.",
+          data,
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createDataRouter,
+};

package/server/routes/export.js

@@ -0,0 +1,25 @@
+const express = require("express");
+const { route } = require("../utils/errors");
+
+function createExportRouter({ exportService }) {
+  const router = express.Router();
+
+  router.post(
+    "/query.csv",
+    route((req, res) => {
+      const result = exportService.exportQuery(req.body.sql);
+      res.setHeader("Content-Type", "text/csv; charset=utf-8");
+      res.setHeader(
+        "Content-Disposition",
+        `attachment; filename="${result.filename}"`
+      );
+      res.send(result.csv);
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createExportRouter,
+};

package/server/routes/overview.js

@@ -0,0 +1,39 @@
+const express = require("express");
+const { route, successResponse } = require("../utils/errors");
+
+function createOverviewRouter({ overviewService }) {
+  const router = express.Router();
+
+  router.get(
+    "/overview",
+    route((req, res) => {
+      const data = overviewService.getOverview();
+      res.json(
+        successResponse({
+          data,
+          readOnly: data.connection.readOnly,
+          warnings: data.warnings,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/status",
+    route((req, res) => {
+      const data = overviewService.getStatus();
+      res.json(
+        successResponse({
+          data,
+          readOnly: data.readOnly,
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createOverviewRouter,
+};

package/server/routes/settings.js

@@ -0,0 +1,50 @@
+const express = require("express");
+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";
+}
+
+function createSettingsRouter({ appStateStore }) {
+  const router = express.Router();
+
+  router.get(
+    "/",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: appStateStore.getSettings(),
+          metadata: {
+            appVersion: readAppVersion(),
+          },
+        })
+      );
+    })
+  );
+
+  router.patch(
+    "/",
+    route((req, res) => {
+      const settings = appStateStore.patchSettings(req.body ?? {});
+      res.json(
+        successResponse({
+          message: "Settings updated.",
+          data: settings,
+          metadata: {
+            appVersion: readAppVersion(),
+          },
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createSettingsRouter,
+};

package/server/routes/sql.js

@@ -0,0 +1,50 @@
+const express = require("express");
+const { route, successResponse } = require("../utils/errors");
+
+function createSqlRouter({ appStateStore, sqlExecutor }) {
+  const router = express.Router();
+
+  router.post(
+    "/execute",
+    route((req, res) => {
+      const result = sqlExecutor.execute(req.body.sql);
+      res.json(
+        successResponse({
+          message: "SQL executed successfully.",
+          data: result,
+          timingMs: result.timingMs,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/history",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: appStateStore.getSqlHistory(),
+        })
+      );
+    })
+  );
+
+  router.delete(
+    "/history",
+    route((req, res) => {
+      appStateStore.clearSqlHistory();
+      res.json(
+        successResponse({
+          message: "SQL history cleared.",
+          data: [],
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createSqlRouter,
+};

package/server/routes/structure.js

@@ -0,0 +1,38 @@
+const express = require("express");
+const { route, successResponse } = require("../utils/errors");
+
+function createStructureRouter({ structureService }) {
+  const router = express.Router();
+
+  router.get(
+    "/",
+    route((req, res) => {
+      const data = structureService.getStructureOverview();
+      res.json(
+        successResponse({
+          data,
+          readOnly: true,
+        })
+      );
+    })
+  );
+
+  router.get(
+    "/:tableName",
+    route((req, res) => {
+      const data = structureService.getTableStructure(req.params.tableName);
+      res.json(
+        successResponse({
+          data,
+          readOnly: data.notSafelyUpdatable,
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createStructureRouter,
+};

package/server/server.js

@@ -0,0 +1,136 @@
+const express = require("express");
+const path = require("node:path");
+const { errorMiddleware } = require("./utils/errors");
+const { AppStateStore } = require("./services/storage/appStateStore");
+const { ConnectionManager } = require("./services/sqlite/connectionManager");
+const { OverviewService } = require("./services/sqlite/overviewService");
+const { SqlExecutor } = require("./services/sqlite/sqlExecutor");
+const { ImportService } = require("./services/sqlite/importService");
+const { ExportService } = require("./services/sqlite/exportService");
+const { StructureService } = require("./services/sqlite/structureService");
+const { DataBrowserService } = require("./services/sqlite/dataBrowserService");
+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 { createSettingsRouter } = require("./routes/settings");
+const { createExportRouter } = require("./routes/export");
+
+const APP_STATE_DB_PATH = path.resolve(__dirname, "..", "data", "sqlite-hub-state.db");
+const LEGACY_STATE_PATH = path.resolve(__dirname, "..", "data", "app-state.json");
+const DEFAULT_PORT = 4173;
+
+const appStateStore = new AppStateStore(APP_STATE_DB_PATH, {
+  legacyFilePath: LEGACY_STATE_PATH,
+});
+const connectionManager = new ConnectionManager({ appStateStore });
+const overviewService = new OverviewService({ connectionManager });
+const sqlExecutor = new SqlExecutor({ connectionManager, appStateStore });
+const importService = new ImportService({ connectionManager });
+const exportService = new ExportService({
+  appStateStore,
+  sqlExecutor,
+});
+const structureService = new StructureService({ connectionManager, appStateStore });
+const dataBrowserService = new DataBrowserService({ connectionManager });
+
+connectionManager.initialize();
+
+const app = express();
+
+app.use(express.json({ limit: "10mb" }));
+app.use(express.urlencoded({ extended: false }));
+
+app.get("/api/health", (req, res) => {
+  res.json({
+    success: true,
+    message: "SQLite Hub backend is running.",
+    data: {
+      connected: Boolean(connectionManager.getActiveConnection()),
+    },
+    metadata: {},
+    warnings: [],
+  });
+});
+
+app.use(
+  "/api/connections",
+  createConnectionsRouter({
+    connectionManager,
+    importService,
+  })
+);
+app.use("/api/db", createOverviewRouter({ overviewService }));
+app.use("/api/sql", createSqlRouter({ appStateStore, sqlExecutor }));
+app.use("/api/structure", createStructureRouter({ structureService }));
+app.use("/api/data", createDataRouter({ dataBrowserService }));
+app.use("/api/settings", createSettingsRouter({ appStateStore }));
+app.use("/api/export", createExportRouter({ exportService }));
+
+app.get("/favicon.ico", (req, res) => {
+  res.status(204).end();
+});
+
+app.get("/", (req, res) => {
+  res.sendFile(path.resolve(__dirname, "..", "index.html"));
+});
+
+app.get("/index.html", (req, res) => {
+  res.sendFile(path.resolve(__dirname, "..", "index.html"));
+});
+
+app.use("/js", express.static(path.resolve(__dirname, "..", "js")));
+app.use("/styles", express.static(path.resolve(__dirname, "..", "styles")));
+app.use("/assets", express.static(path.resolve(__dirname, "..", "assets")));
+app.use(errorMiddleware);
+
+function resolvePort(value = process.env.PORT) {
+  if (value === undefined || value === null || value === "") {
+    return DEFAULT_PORT;
+  }
+
+  const port = Number(value);
+
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port: ${value}`);
+  }
+
+  return port;
+}
+
+function startServer({ port } = {}) {
+  const resolvedPort = resolvePort(port);
+
+  return new Promise((resolve, reject) => {
+    const server = app.listen(resolvedPort);
+
+    server.once("error", reject);
+    server.once("listening", () => {
+      const url = `http://127.0.0.1:${resolvedPort}`;
+
+      console.log(`SQLite Hub server listening on ${url}`);
+      resolve({
+        port: resolvedPort,
+        server,
+        url,
+      });
+    });
+  });
+}
+
+if (require.main === module) {
+  startServer().catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  app,
+  appStateStore,
+  connectionManager,
+  DEFAULT_PORT,
+  resolvePort,
+  startServer,
+};