sqlite-hub 0.17.2 → 1.0.0

package/server/services/nativeFileDialogService.js

@@ -90,6 +90,79 @@ function buildDialogAttempts({ platform = process.platform, homeDirectory = os.h
   ];
 }
 
+function buildOpenDialogAttempts({ platform = process.platform, homeDirectory = os.homedir() } = {}) {
+  if (platform === "darwin") {
+    return [
+      {
+        command: "osascript",
+        args: [
+          "-e",
+          "on run argv",
+          "-e",
+          'set selectedFile to choose file with prompt "Open SQLite Database" default location POSIX file (item 1 of argv)',
+          "-e",
+          "return POSIX path of selectedFile",
+          "-e",
+          "end run",
+          homeDirectory,
+        ],
+        cancelledExitCodes: new Set([1]),
+        cancelledErrorPattern: /user canceled|-128/i,
+      },
+    ];
+  }
+
+  if (platform === "win32") {
+    const initialDirectory = escapePowerShellSingleQuotedString(homeDirectory);
+    const script = [
+      "Add-Type -AssemblyName System.Windows.Forms",
+      "$dialog = New-Object System.Windows.Forms.OpenFileDialog",
+      "$dialog.Title = 'Open SQLite Database'",
+      "$dialog.Filter = 'SQLite databases (*.db;*.sqlite;*.sqlite3)|*.db;*.sqlite;*.sqlite3|All files (*.*)|*.*'",
+      "$dialog.CheckFileExists = $true",
+      `$dialog.InitialDirectory = '${initialDirectory}'`,
+      "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
+      "  [Console]::Out.Write($dialog.FileName)",
+      "} else {",
+      "  exit 2",
+      "}",
+    ].join("; ");
+
+    return [
+      {
+        command: "powershell.exe",
+        args: ["-NoProfile", "-STA", "-Command", script],
+        cancelledExitCodes: new Set([2]),
+      },
+    ];
+  }
+
+  return [
+    {
+      command: "zenity",
+      args: [
+        "--file-selection",
+        "--title=Open SQLite Database",
+        `--filename=${homeDirectory}${path.sep}`,
+        "--file-filter=SQLite databases | *.db *.sqlite *.sqlite3",
+        "--file-filter=All files | *",
+      ],
+      cancelledExitCodes: new Set([1]),
+    },
+    {
+      command: "kdialog",
+      args: [
+        "--getopenfilename",
+        homeDirectory,
+        "SQLite databases (*.db *.sqlite *.sqlite3);;All files (*)",
+        "--title",
+        "Open SQLite Database",
+      ],
+      cancelledExitCodes: new Set([1]),
+    },
+  ];
+}
+
 function normalizeSelectedDatabasePath(value) {
   const selectedPath = String(value ?? "").trim();
 
@@ -100,6 +173,10 @@ function normalizeSelectedDatabasePath(value) {
   return path.extname(selectedPath) ? selectedPath : `${selectedPath}.sqlite`;
 }
 
+function normalizeOpenedDatabasePath(value) {
+  return String(value ?? "").trim() || null;
+}
+
 function isMissingDialogCommand(error) {
   return error?.code === "ENOENT";
 }
@@ -129,6 +206,19 @@ class NativeFileDialogService {
       homeDirectory: this.homeDirectory,
     });
 
+    return this.runDialogAttempts(attempts, normalizeSelectedDatabasePath);
+  }
+
+  async chooseOpenDatabasePath() {
+    const attempts = buildOpenDialogAttempts({
+      platform: this.platform,
+      homeDirectory: this.homeDirectory,
+    });
+
+    return this.runDialogAttempts(attempts, normalizeOpenedDatabasePath);
+  }
+
+  async runDialogAttempts(attempts, normalizePath) {
     for (const attempt of attempts) {
       try {
         const result = await this.executeFile(attempt.command, attempt.args, {
@@ -136,7 +226,7 @@ class NativeFileDialogService {
           windowsHide: true,
         });
 
-        return normalizeSelectedDatabasePath(result?.stdout);
+        return normalizePath(result?.stdout);
       } catch (error) {
         if (isCancelledDialog(error, attempt)) {
           return null;
@@ -164,5 +254,7 @@ module.exports = {
   DEFAULT_DATABASE_FILENAME,
   NativeFileDialogService,
   buildDialogAttempts,
+  buildOpenDialogAttempts,
+  normalizeOpenedDatabasePath,
   normalizeSelectedDatabasePath,
 };

package/server/services/storage/appStateStore.js

@@ -457,6 +457,19 @@ class AppStateStore {
 
       CREATE INDEX IF NOT EXISTS idx_database_documents_database_updated
       ON database_documents(database_key, updated_at DESC, id ASC);
+
+      CREATE TABLE IF NOT EXISTS api_tokens (
+        id TEXT PRIMARY KEY,
+        database_key TEXT NOT NULL,
+        name TEXT NOT NULL,
+        token_hash TEXT NOT NULL UNIQUE,
+        token_prefix TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        last_used_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_api_tokens_database_created
+      ON api_tokens(database_key, created_at DESC, id ASC);
     `);
 
     const recentConnectionColumns = new Set(
@@ -2335,6 +2348,106 @@ class AppStateStore {
     return this.getSettings();
   }
 
+  decorateApiTokenRow(row = {}) {
+    return {
+      id: String(row.id ?? ""),
+      databaseKey: String(row.database_key ?? row.databaseKey ?? ""),
+      name: String(row.name ?? ""),
+      tokenPrefix: String(row.token_prefix ?? row.tokenPrefix ?? ""),
+      createdAt: row.created_at ?? row.createdAt ?? null,
+      lastUsedAt: row.last_used_at ?? row.lastUsedAt ?? null,
+    };
+  }
+
+  listApiTokens(databaseKey) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+
+    return this.db
+      .prepare(
+        `
+          SELECT id, database_key, name, token_prefix, created_at, last_used_at
+          FROM api_tokens
+          WHERE database_key = ?
+          ORDER BY created_at DESC, id ASC
+        `
+      )
+      .all(normalizedDatabaseKey)
+      .map((row) => this.decorateApiTokenRow(row));
+  }
+
+  createApiToken({ databaseKey, name, tokenHash, tokenPrefix }) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+    const id = crypto.randomUUID();
+    const createdAt = new Date().toISOString();
+
+    this.db
+      .prepare(
+        `
+          INSERT INTO api_tokens (
+            id,
+            database_key,
+            name,
+            token_hash,
+            token_prefix,
+            created_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?)
+        `
+      )
+      .run(id, normalizedDatabaseKey, name, tokenHash, tokenPrefix, createdAt);
+
+    return this.listApiTokens(normalizedDatabaseKey).find((token) => token.id === id);
+  }
+
+  findApiTokenByHash(tokenHash) {
+    const normalizedTokenHash = String(tokenHash ?? "").trim();
+
+    if (!normalizedTokenHash) {
+      return null;
+    }
+
+    const row = this.db
+      .prepare(
+        `
+          SELECT id, database_key, name, token_prefix, created_at, last_used_at
+          FROM api_tokens
+          WHERE token_hash = ?
+          LIMIT 1
+        `
+      )
+      .get(normalizedTokenHash);
+
+    return row ? this.decorateApiTokenRow(row) : null;
+  }
+
+  touchApiToken(tokenId) {
+    this.db
+      .prepare("UPDATE api_tokens SET last_used_at = ? WHERE id = ?")
+      .run(new Date().toISOString(), String(tokenId ?? "").trim());
+  }
+
+  deleteApiToken(databaseKey, tokenId) {
+    const normalizedDatabaseKey = normalizeDocumentDatabaseKey(databaseKey);
+    const normalizedTokenId = String(tokenId ?? "").trim();
+
+    if (!normalizedTokenId) {
+      throw new ValidationError("Token id is required.");
+    }
+
+    const result = this.db
+      .prepare("DELETE FROM api_tokens WHERE database_key = ? AND id = ?")
+      .run(normalizedDatabaseKey, normalizedTokenId);
+
+    if (result.changes < 1) {
+      throw new NotFoundError("API token was not found.");
+    }
+
+    return {
+      id: normalizedTokenId,
+      deleted: true,
+    };
+  }
+
   decorateDatabaseDocumentRow(row = {}) {
     return {
       id: String(row.id ?? ""),

package/server/utils/errors.js

@@ -29,6 +29,12 @@ class ConflictError extends AppError {
   }
 }
 
+class AuthenticationError extends AppError {
+  constructor(message = "Authentication required.", options = {}) {
+    super(message, 401, { code: "AUTHENTICATION_REQUIRED", ...options });
+  }
+}
+
 class BusyError extends AppError {
   constructor(message, options = {}) {
     super(message, 423, { code: "SQLITE_BUSY", ...options });
@@ -161,6 +167,7 @@ function errorMiddleware(error, req, res, next) {
 
 module.exports = {
   AppError,
+  AuthenticationError,
   BusyError,
   ConflictError,
   DatabaseRequiredError,

package/tests/api-token-auth.test.js

@@ -0,0 +1,127 @@
+const assert = require("node:assert/strict");
+const express = require("express");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+
+const { createExternalApiRouter } = require("../server/routes/externalApi");
+const { ApiTokenService } = require("../server/services/apiTokenService");
+const { AppStateStore } = require("../server/services/storage/appStateStore");
+const { errorMiddleware } = require("../server/utils/errors");
+
+function createConnection(id, label, databasePath) {
+  return {
+    id,
+    label,
+    path: databasePath,
+    lastOpenedAt: new Date().toISOString(),
+    lastModifiedAt: new Date().toISOString(),
+    sizeBytes: 0,
+    readOnly: false,
+    logoPath: null,
+  };
+}
+
+async function startApi(t) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-hub-api-token-"));
+  const store = new AppStateStore(path.join(directory, "state.db"));
+  const databaseA = createConnection("db-a", "Database A", path.join(directory, "a.db"));
+  const databaseB = createConnection("db-b", "Database B", path.join(directory, "b.db"));
+
+  store.upsertRecentConnection(databaseA);
+  store.upsertRecentConnection(databaseB, { makeActive: false });
+
+  const tokenService = new ApiTokenService({ appStateStore: store });
+  const serviceCalls = [];
+  const databaseService = {
+    listTables(databaseId) {
+      serviceCalls.push(databaseId);
+      return [{ name: "companies" }];
+    },
+  };
+  const app = express();
+
+  app.use(express.json());
+  app.use(
+    "/api/v1",
+    createExternalApiRouter({ databaseService, tokenService })
+  );
+  app.use(errorMiddleware);
+
+  const server = await new Promise((resolve) => {
+    const listener = app.listen(0, "127.0.0.1", () => resolve(listener));
+  });
+
+  t.after(async () => {
+    await new Promise((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    });
+    store.db.close();
+    fs.rmSync(directory, { recursive: true, force: true });
+  });
+
+  return {
+    baseUrl: `http://127.0.0.1:${server.address().port}/api/v1`,
+    databaseA,
+    databaseB,
+    serviceCalls,
+    store,
+    tokenService,
+  };
+}
+
+test("tokens are hashed, deletable, and isolated per database", async (t) => {
+  const fixture = await startApi(t);
+  const created = fixture.tokenService.createToken(fixture.databaseA.id, "Automation");
+
+  assert.match(created.token, /^shub_[A-Za-z0-9_-]+$/);
+  assert.equal(fixture.tokenService.listTokens(fixture.databaseA.id)[0].token, undefined);
+
+  const stored = fixture.store.db
+    .prepare("SELECT token_hash, token_prefix FROM api_tokens WHERE id = ?")
+    .get(created.id);
+
+  assert.notEqual(stored.token_hash, created.token);
+  assert.equal(stored.token_prefix, created.tokenPrefix);
+  assert.equal(fixture.tokenService.authenticate(fixture.databaseA.id, created.token).id, created.id);
+  assert.throws(
+    () => fixture.tokenService.authenticate(fixture.databaseB.id, created.token),
+    /invalid for this database/
+  );
+
+  const validResponse = await fetch(
+    `${fixture.baseUrl}/databases/${fixture.databaseA.id}/tables`,
+    { headers: { Authorization: `Bearer ${created.token}` } }
+  );
+  const validPayload = await validResponse.json();
+
+  assert.equal(validResponse.status, 200);
+  assert.deepEqual(validPayload.data.items, [{ name: "companies" }]);
+  assert.deepEqual(fixture.serviceCalls, [fixture.databaseA.id]);
+
+  const invalidResponse = await fetch(
+    `${fixture.baseUrl}/databases/${fixture.databaseA.id}/tables`,
+    { headers: { Authorization: "Bearer invalid" } }
+  );
+  assert.equal(invalidResponse.status, 401);
+
+  const missingResponse = await fetch(
+    `${fixture.baseUrl}/databases/${fixture.databaseA.id}/tables`
+  );
+  assert.equal(missingResponse.status, 401);
+
+  const wrongDatabaseResponse = await fetch(
+    `${fixture.baseUrl}/databases/${fixture.databaseB.id}/tables`,
+    { headers: { Authorization: `Bearer ${created.token}` } }
+  );
+  assert.equal(wrongDatabaseResponse.status, 401);
+  assert.deepEqual(fixture.serviceCalls, [fixture.databaseA.id]);
+
+  fixture.tokenService.deleteToken(fixture.databaseA.id, created.id);
+  assert.equal(fixture.tokenService.listTokens(fixture.databaseA.id).length, 0);
+  assert.throws(
+    () => fixture.tokenService.authenticate(fixture.databaseA.id, created.token),
+    /invalid for this database/
+  );
+});

package/tests/cli-service-delegation.test.js

@@ -0,0 +1,43 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { main } = require("../bin/sqlite-hub");
+
+test("CLI delegates database operations to the shared command service", async () => {
+  const calls = [];
+  const connection = {
+    id: "db-one",
+    label: "Database One",
+  };
+  const databaseService = {
+    getDatabase(reference) {
+      calls.push(["getDatabase", reference]);
+      return connection;
+    },
+    listDatabases() {
+      calls.push(["listDatabases"]);
+      return [connection];
+    },
+    listTables(reference) {
+      calls.push(["listTables", reference]);
+      return [{ name: "companies" }];
+    },
+  };
+  const output = [];
+  const originalLog = console.log;
+
+  console.log = (...values) => output.push(values.join(" "));
+
+  try {
+    await main(["--database:Database One", "--tables"], { databaseService });
+  } finally {
+    console.log = originalLog;
+  }
+
+  assert.deepEqual(calls, [
+    ["listDatabases"],
+    ["getDatabase", "Database One"],
+    ["listTables", "db-one"],
+  ]);
+  assert.match(output.join("\n"), /companies/);
+});

package/tests/connections-file-dialog-route.test.js

@@ -15,6 +15,7 @@ test("connections route returns the path selected by the native dialog", async (
       backupService: {},
       nativeFileDialogService: {
         chooseCreateDatabasePath: async () => "/tmp/new-database.sqlite",
+        chooseOpenDatabasePath: async () => "/tmp/existing-database.db",
       },
     })
   );
@@ -44,3 +45,45 @@ test("connections route returns the path selected by the native dialog", async (
     });
   }
 });
+
+test("connections route returns the existing database selected by the native dialog", async () => {
+  const app = express();
+  app.use(express.json());
+  app.use(
+    "/api/connections",
+    createConnectionsRouter({
+      connectionManager: {},
+      importService: {},
+      backupService: {},
+      nativeFileDialogService: {
+        chooseCreateDatabasePath: async () => null,
+        chooseOpenDatabasePath: async () => "/tmp/existing-database.db",
+      },
+    })
+  );
+  app.use(errorMiddleware);
+
+  const server = await new Promise((resolve) => {
+    const listener = app.listen(0, "127.0.0.1", () => resolve(listener));
+  });
+
+  try {
+    const address = server.address();
+    const response = await fetch(
+      `http://127.0.0.1:${address.port}/api/connections/choose-open-path`,
+      { method: "POST" }
+    );
+    const payload = await response.json();
+
+    assert.equal(response.status, 200);
+    assert.equal(payload.success, true);
+    assert.deepEqual(payload.data, {
+      cancelled: false,
+      path: "/tmp/existing-database.db",
+    });
+  } finally {
+    await new Promise((resolve, reject) => {
+      server.close((error) => (error ? reject(error) : resolve()));
+    });
+  }
+});

package/tests/copy-column-modal.test.js

@@ -95,3 +95,37 @@ test("create database modal offers a native path picker and manual fallback", as
   assert.match(html, /name="path"/);
   assert.match(html, /enter an absolute path manually/);
 });
+
+test("open database modal offers a native file picker and manual fallback", async () => {
+  const { renderOpenConnectionForm } = await loadModalModule();
+  const html = renderOpenConnectionForm({
+    kind: "open-connection",
+    error: null,
+    submitting: false,
+  });
+
+  assert.match(html, /data-action="choose-open-database-path"/);
+  assert.match(html, /data-open-database-path/);
+  assert.match(html, /name="path"/);
+  assert.match(html, /enter an absolute path manually/);
+});
+
+test("API token deletion uses the shared confirmation modal", async () => {
+  const { renderDeleteApiTokenForm } = await loadModalModule();
+  const html = renderDeleteApiTokenForm({
+    kind: "delete-api-token",
+    tokenId: "token-one",
+    tokenName: "Automation",
+    tokenPrefix: "shub_example",
+    databaseLabel: "Database One",
+    error: null,
+    submitting: false,
+  });
+
+  assert.match(html, /Delete API token/);
+  assert.match(html, /Automation/);
+  assert.match(html, /Database One/);
+  assert.match(html, /shub_example\.\.\./);
+  assert.match(html, /data-form="delete-api-token-confirm"/);
+  assert.match(html, /Delete Token/);
+});

package/tests/database-command-service.test.js

@@ -0,0 +1,102 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+const Database = require("better-sqlite3");
+
+const { DatabaseCommandService } = require("../server/services/databaseCommandService");
+const { AppStateStore } = require("../server/services/storage/appStateStore");
+
+function createFixture(t) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-hub-command-service-"));
+  const databasePath = path.join(directory, "sample.db");
+  const targetDb = new Database(databasePath);
+
+  targetDb.exec(`
+    CREATE TABLE companies (id INTEGER PRIMARY KEY, name TEXT NOT NULL);
+    INSERT INTO companies (name) VALUES ('Acme'), ('Globex');
+  `);
+  targetDb.close();
+
+  const store = new AppStateStore(path.join(directory, "state.db"));
+  const connection = {
+    id: "db-sample",
+    label: "Sample",
+    path: databasePath,
+    lastOpenedAt: new Date().toISOString(),
+    lastModifiedAt: new Date().toISOString(),
+    sizeBytes: fs.statSync(databasePath).size,
+    readOnly: false,
+    logoPath: null,
+  };
+
+  store.upsertRecentConnection(connection);
+  store.db
+    .prepare(
+      `
+        INSERT INTO query_history (
+          database_key,
+          normalized_sql,
+          raw_sql,
+          title,
+          notes,
+          query_type,
+          tables_detected,
+          is_saved,
+          first_executed_at,
+          last_used_at
+        )
+        VALUES (?, ?, ?, ?, ?, 'select', '["companies"]', 1, ?, ?)
+      `
+    )
+    .run(
+      connection.id,
+      "select id, name from companies order by id",
+      "SELECT id, name FROM companies ORDER BY id",
+      "Company List",
+      "Used by CLI and API",
+      new Date().toISOString(),
+      new Date().toISOString()
+    );
+  store.createDatabaseDocument(connection.id, {
+    filename: "Readme.md",
+    content: "# Sample\n",
+  });
+
+  t.after(() => {
+    store.db.close();
+    fs.rmSync(directory, { recursive: true, force: true });
+  });
+
+  return {
+    connection,
+    service: new DatabaseCommandService({ appStateStore: store }),
+  };
+}
+
+test("database command service provides shared CLI and API operations", (t) => {
+  const { connection, service } = createFixture(t);
+
+  assert.equal(service.getDatabase("sample").id, connection.id);
+  assert.deepEqual(service.listTables(connection.id), [{ name: "companies" }]);
+  assert.equal(service.getTable(connection.id, "companies").rowCount, 2);
+
+  const row = service.getTableRow(connection.id, "companies", "1");
+  assert.deepEqual(row.data, { id: 1, name: "Acme" });
+  assert.equal(row.identity.kind, "primaryKey");
+
+  const queries = service.listSavedQueries(connection.id);
+  assert.equal(queries.total, 1);
+  assert.equal(service.getSavedQuery(connection.id, "Company List").notes, "Used by CLI and API");
+
+  const execution = service.executeSavedQuery(connection.id, "Company List");
+  assert.equal(execution.result.statements[0].rowCount, 2);
+
+  const exported = service.exportSavedQuery(connection.id, "Company List", "csv");
+  assert.equal(exported.result.rowCount, 2);
+  assert.match(exported.result.content, /Acme/);
+
+  assert.equal(service.listDocuments(connection.id).length, 1);
+  assert.equal(service.getDocument(connection.id, "Readme").content, "# Sample\n");
+});

package/tests/form-controls.test.js

@@ -0,0 +1,34 @@
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+const test = require('node:test');
+
+let formControlsModulePromise = null;
+
+function loadFormControlsModule() {
+    if (!formControlsModulePromise) {
+        formControlsModulePromise = import(
+            pathToFileURL(path.resolve(__dirname, '../frontend/js/components/formControls.js')).href
+        );
+    }
+
+    return formControlsModulePromise;
+}
+
+test('standard text input uses the shared application styling', async () => {
+    const { renderTextInput } = await loadFormControlsModule();
+    const markup = renderTextInput({
+        className: 'flex-1',
+        dataAttributes: { tokenName: true },
+        maxlength: 80,
+        placeholder: 'Token name',
+    });
+
+    assert.match(markup, /control-input/);
+    assert.match(markup, /border-outline-variant\/20/);
+    assert.match(markup, /bg-surface-container-lowest/);
+    assert.match(markup, /placeholder:text-on-surface-variant\/35/);
+    assert.match(markup, /focus:border-primary-container/);
+    assert.match(markup, /data-token-name/);
+    assert.match(markup, /maxlength="80"/);
+});