sqlite-hub 1.2.0 → 1.4.0

package/package.json

@@ -1,12 +1,26 @@
 {
     "name": "sqlite-hub",
-    "version": "1.2.0",
+    "version": "1.4.0",
     "description": "SQLite-only local management app backend and SPA shell",
     "license": "MIT",
     "main": "server/server.js",
     "bin": {
         "sqlite-hub": "bin/sqlite-hub.js"
     },
+    "files": [
+        "bin/",
+        "docs/",
+        "examples/",
+        "frontend/",
+        "server/data/.gitkeep",
+        "server/data/db_logos/.gitkeep",
+        "server/middleware/",
+        "server/routes/",
+        "server/server.js",
+        "server/services/",
+        "server/utils/",
+        "tailwind.config.cjs"
+    ],
     "scripts": {
         "build": "npm run build:css",
         "build:css": "tailwindcss -i ./frontend/styles/tailwind.css -o ./frontend/styles/tailwind.generated.css --minify",
@@ -15,7 +29,9 @@
         "start": "node bin/sqlite-hub.js",
         "dev": "node --watch server/server.js --port:4180",
         "prepack": "npm run build:css",
-        "publish": "bash scripts/publish_brew.sh && sleep 10 && npm login --auth-type=web && bash scripts/publish_npm.sh"
+        "publish": "bash scripts/publish_brew.sh && sleep 10 && bash scripts/publish_npm.sh",
+        "screenshots": "node scripts/screenshot_sqlite_hub.js --width:1920 --height:1280",
+        "screenshots:backup-drawer": "node scripts/screenshot_backup_drawer.js"
     },
     "dependencies": {
         "better-sqlite3": "^12.10.1",

package/server/routes/backups.js

@@ -27,6 +27,19 @@ function createBackupsRouter({ backupService }) {
     })
   );
 
+  router.get(
+    "/:backupId/diff",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: backupService.diffBackupWithCurrent(req.params.backupId, {
+            sampleLimit: req.query.sampleLimit,
+          }),
+        })
+      );
+    })
+  );
+
   router.post(
     "/",
     route(async (req, res) => {
@@ -49,11 +62,14 @@ function createBackupsRouter({ backupService }) {
   router.patch(
     "/:backupId",
     route((req, res) => {
-      const backup = backupService.updateBackupNotes(req.params.backupId, req.body?.notes ?? "");
+      const backup = backupService.updateBackupDetails(req.params.backupId, {
+        name: req.body?.name,
+        notes: req.body?.notes,
+      });
 
       res.json(
         successResponse({
-          message: "Backup notes updated.",
+          message: "Backup updated.",
           data: backup,
         })
       );

package/server/routes/externalApi.js

@@ -154,6 +154,42 @@ function createExternalApiRouter({ databaseService, tokenService, appInfoService
     })
   );
 
+  router.post(
+    "/databases/:databaseId/tables/:tableName/types",
+    route((req, res) => {
+      const target = String(req.body?.target ?? "").trim();
+
+      if (!["typescript", "rust", "kotlin", "swift"].includes(target)) {
+        throw new ValidationError(
+          `Unsupported type target "${req.body?.target}". Supported targets: typescript, rust, kotlin, swift.`,
+          { code: "INVALID_TYPE_TARGET" }
+        );
+      }
+
+      const result = databaseService.generateTableTypes(
+        req.params.databaseId,
+        req.params.tableName,
+        target,
+        req.body?.options ?? {}
+      );
+      const { warnings, metadata, ...data } = result;
+
+      res.json(
+        successResponse({
+          message: "Types generated.",
+          data,
+          metadata: {
+            databaseId: req.params.databaseId,
+            tableName: req.params.tableName,
+            ...metadata,
+          },
+          warnings,
+          readOnly: true,
+        })
+      );
+    })
+  );
+
   router.get(
     "/databases/:databaseId/queries",
     route((req, res) => {

package/server/routes/structure.js

@@ -30,6 +30,28 @@ function createStructureRouter({ structureService }) {
     })
   );
 
+  router.post(
+    "/:tableName/types",
+    route((req, res) => {
+      const result = structureService.generateTableTypes(
+        req.params.tableName,
+        req.body?.target,
+        req.body?.options ?? {}
+      );
+      const { warnings, metadata, ...data } = result;
+
+      res.json(
+        successResponse({
+          message: "Types generated.",
+          data,
+          metadata,
+          warnings,
+          readOnly: true,
+        })
+      );
+    })
+  );
+
   return router;
 }
 

package/server/services/databaseCommandService.js

@@ -5,6 +5,7 @@ const { DataBrowserService } = require("./sqlite/dataBrowserService");
 const { ExportService } = require("./sqlite/exportService");
 const { getTableDetail } = require("./sqlite/introspection");
 const { SqlExecutor } = require("./sqlite/sqlExecutor");
+const { TypeGenerationService } = require("./typeGenerationService");
 
 function normalizeLookupValue(value, label) {
   const normalized = String(value ?? "").trim();
@@ -166,6 +167,7 @@ class DatabaseCommandService {
   constructor({ appStateStore, runtimeFactory } = {}) {
     this.appStateStore = appStateStore;
     this.runtimeFactory = runtimeFactory ?? ((connection, options) => this.createRuntime(connection, options));
+    this.typeGenerationService = new TypeGenerationService();
   }
 
   listDatabases() {
@@ -250,6 +252,18 @@ class DatabaseCommandService {
     );
   }
 
+  generateTableTypes(databaseReference, tableName, target, options = {}) {
+    const normalizedTableName = normalizeLookupValue(tableName, "Table name");
+    return this.withDatabase(databaseReference, ({ runtime }) =>
+      this.typeGenerationService.generateTypesFromDatabase(
+        runtime.db,
+        normalizedTableName,
+        target,
+        options
+      )
+    );
+  }
+
   getTableRow(databaseReference, tableName, exportTarget) {
     const normalizedTableName = normalizeLookupValue(tableName, "Table name");
     normalizeLookupValue(exportTarget, "Row key");