sqlite-hub 1.0.0 → 1.1.0

package/server/services/sqlite/exportService.js

@@ -1,5 +1,8 @@
+const { PassThrough } = require("node:stream");
+const parquet = require("parquetjs-lite");
 const { quoteIdentifier } = require("../../utils/identifier");
 const { serializeRows } = require("../../utils/sqliteTypes");
+const { ValidationError } = require("../../utils/errors");
 const {
   rowsToCsv,
   rowsToDelimitedText,
@@ -41,6 +44,14 @@ const EXPORT_FORMATS = {
     extension: "md",
     mimeType: "text/markdown; charset=utf-8",
   },
+  json: {
+    extension: "json",
+    mimeType: "application/json; charset=utf-8",
+  },
+  parquet: {
+    extension: "parquet",
+    mimeType: "application/vnd.apache.parquet",
+  },
 };
 
 function normalizeExportFormat(format) {
@@ -54,6 +65,20 @@ function normalizeExportFormat(format) {
 }
 
 function renderExportContent({ columns, rows, format, csvDelimiter }) {
+  if (format === "parquet") {
+    throw new ValidationError("Parquet exports are binary and must use a download endpoint.");
+  }
+
+  if (format === "json") {
+    return JSON.stringify(
+      rows.map((row) =>
+        Object.fromEntries(columns.map((column) => [column, row[column]]))
+      ),
+      null,
+      2
+    );
+  }
+
   if (format === "tsv") {
     return rowsToDelimitedText({ columns, rows, delimiter: "\t" });
   }
@@ -65,6 +90,206 @@ function renderExportContent({ columns, rows, format, csvDelimiter }) {
   return rowsToCsv({ columns, rows, delimiter: csvDelimiter });
 }
 
+function isSerializedBlob(value) {
+  return (
+    value &&
+    typeof value === "object" &&
+    value.__type === "blob" &&
+    typeof value.data === "string"
+  );
+}
+
+function getParquetValueKind(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array || isSerializedBlob(value)) {
+    return "blob";
+  }
+
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Number.isInteger(value) ? "integer" : "number";
+  }
+
+  return "string";
+}
+
+function inferParquetColumnType(rows, column) {
+  const kinds = new Set();
+
+  for (const row of rows) {
+    const kind = getParquetValueKind(row?.[column]);
+
+    if (kind) {
+      kinds.add(kind);
+    }
+  }
+
+  if (kinds.size === 0) {
+    return "UTF8";
+  }
+
+  if (kinds.size === 1 && kinds.has("blob")) {
+    return "BYTE_ARRAY";
+  }
+
+  if (kinds.size === 1 && kinds.has("boolean")) {
+    return "BOOLEAN";
+  }
+
+  if (kinds.size === 1 && kinds.has("integer")) {
+    return "INT64";
+  }
+
+  if (
+    (kinds.size === 1 && kinds.has("number")) ||
+    (kinds.size === 2 && kinds.has("integer") && kinds.has("number"))
+  ) {
+    return "DOUBLE";
+  }
+
+  return "UTF8";
+}
+
+function stringifyParquetValue(value) {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+
+  if (typeof value === "string") {
+    return value;
+  }
+
+  if (Buffer.isBuffer(value)) {
+    return value.toString("base64");
+  }
+
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value).toString("base64");
+  }
+
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+
+  return String(value);
+}
+
+function normalizeParquetBlob(value) {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+
+  if (Buffer.isBuffer(value)) {
+    return value;
+  }
+
+  if (value instanceof Uint8Array) {
+    return Buffer.from(value);
+  }
+
+  if (isSerializedBlob(value)) {
+    return Buffer.from(value.data, value.encoding === "hex" ? "hex" : "base64");
+  }
+
+  return Buffer.from(stringifyParquetValue(value) ?? "", "utf8");
+}
+
+function normalizeParquetValue(value, type) {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+
+  if (type === "BYTE_ARRAY") {
+    return normalizeParquetBlob(value);
+  }
+
+  if (type === "BOOLEAN") {
+    return Boolean(value);
+  }
+
+  if (type === "INT64" || type === "DOUBLE") {
+    return Number(value);
+  }
+
+  return stringifyParquetValue(value);
+}
+
+function createParquetSchema(columns, rows) {
+  return new parquet.ParquetSchema(
+    Object.fromEntries(
+      columns.map((column) => [
+        column,
+        {
+          type: inferParquetColumnType(rows, column),
+          optional: true,
+        },
+      ])
+    )
+  );
+}
+
+async function rowsToParquetBuffer({ columns, rows }) {
+  const schema = createParquetSchema(columns, rows);
+  const output = new PassThrough();
+  const chunks = [];
+  const finished = new Promise((resolve, reject) => {
+    output.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    output.on("end", resolve);
+    output.on("error", reject);
+  });
+  const writer = await parquet.ParquetWriter.openStream(schema, output, {
+    useDataPageV2: false,
+  });
+  const columnTypes = Object.fromEntries(
+    columns.map((column) => [column, schema.schema[column].type])
+  );
+
+  for (const row of rows) {
+    const parquetRow = {};
+
+    for (const column of columns) {
+      const value = normalizeParquetValue(row?.[column], columnTypes[column]);
+
+      if (value !== undefined) {
+        parquetRow[column] = value;
+      }
+    }
+
+    await writer.appendRow(parquetRow);
+  }
+
+  await writer.close();
+  await finished;
+
+  return Buffer.concat(chunks);
+}
+
+async function renderDownloadContent({ columns, rows, format, csvDelimiter }) {
+  if (format === "parquet") {
+    return rowsToParquetBuffer({ columns, rows });
+  }
+
+  return renderExportContent({ columns, rows, format, csvDelimiter });
+}
+
+function buildExportResult({ filenameBase, formatConfig, content, format, columns, rowCount }) {
+  return {
+    filename: `${filenameBase}.${formatConfig.extension}`,
+    content,
+    csv: format === "csv" ? content : undefined,
+    format,
+    mimeType: formatConfig.mimeType,
+    columns,
+    rowCount,
+  };
+}
+
 class ExportService {
   constructor({ appStateStore, connectionManager, sqlExecutor }) {
     this.appStateStore = appStateStore;
@@ -76,7 +301,7 @@ class ExportService {
     return this.appStateStore.getSettings().csvDelimiter || ",";
   }
 
-  exportQuery(sql, options = {}) {
+  buildQueryExportData(sql, options = {}) {
     const format = normalizeExportFormat(options.format);
     const formatConfig = EXPORT_FORMATS[format];
     const activeConnection = this.connectionManager.getActiveConnection();
@@ -96,25 +321,55 @@ class ExportService {
       persistHistory: false,
       requireReader: true,
     });
-    const content = renderExportContent({
+
+    return {
+      filenameBase,
+      format,
+      formatConfig,
       columns: result.columns,
       rows: result.rows,
-      format,
+    };
+  }
+
+  exportQuery(sql, options = {}) {
+    const exportData = this.buildQueryExportData(sql, options);
+    const content = renderExportContent({
+      columns: exportData.columns,
+      rows: exportData.rows,
+      format: exportData.format,
       csvDelimiter: this.getDelimiter(),
     });
 
-    return {
-      filename: `${filenameBase}.${formatConfig.extension}`,
+    return buildExportResult({
+      filenameBase: exportData.filenameBase,
+      formatConfig: exportData.formatConfig,
       content,
-      csv: format === "csv" ? content : undefined,
-      format,
-      mimeType: formatConfig.mimeType,
-      columns: result.columns,
-      rowCount: result.rows.length,
-    };
+      format: exportData.format,
+      columns: exportData.columns,
+      rowCount: exportData.rows.length,
+    });
   }
 
-  exportTable(tableName, options = {}) {
+  async exportQueryDownload(sql, options = {}) {
+    const exportData = this.buildQueryExportData(sql, options);
+    const content = await renderDownloadContent({
+      columns: exportData.columns,
+      rows: exportData.rows,
+      format: exportData.format,
+      csvDelimiter: this.getDelimiter(),
+    });
+
+    return buildExportResult({
+      filenameBase: exportData.filenameBase,
+      formatConfig: exportData.formatConfig,
+      content,
+      format: exportData.format,
+      columns: exportData.columns,
+      rowCount: exportData.rows.length,
+    });
+  }
+
+  buildTableExportData(tableName, options = {}) {
     const format = normalizeExportFormat(options.format);
     const formatConfig = EXPORT_FORMATS[format];
     const db = this.connectionManager.getActiveDatabase();
@@ -138,22 +393,52 @@ class ExportService {
       blobMode: "full",
     });
     const columns = statement.columns().map((column) => column.name);
-    const content = renderExportContent({
+
+    return {
+      filenameBase: tableName,
+      format,
+      formatConfig,
       columns,
       rows,
-      format,
+    };
+  }
+
+  exportTable(tableName, options = {}) {
+    const exportData = this.buildTableExportData(tableName, options);
+    const content = renderExportContent({
+      columns: exportData.columns,
+      rows: exportData.rows,
+      format: exportData.format,
       csvDelimiter: this.getDelimiter(),
     });
 
-    return {
-      filename: `${tableName}.${formatConfig.extension}`,
+    return buildExportResult({
+      filenameBase: exportData.filenameBase,
+      formatConfig: exportData.formatConfig,
       content,
-      csv: format === "csv" ? content : undefined,
-      format,
-      mimeType: formatConfig.mimeType,
-      columns,
-      rowCount: rows.length,
-    };
+      format: exportData.format,
+      columns: exportData.columns,
+      rowCount: exportData.rows.length,
+    });
+  }
+
+  async exportTableDownload(tableName, options = {}) {
+    const exportData = this.buildTableExportData(tableName, options);
+    const content = await renderDownloadContent({
+      columns: exportData.columns,
+      rows: exportData.rows,
+      format: exportData.format,
+      csvDelimiter: this.getDelimiter(),
+    });
+
+    return buildExportResult({
+      filenameBase: exportData.filenameBase,
+      formatConfig: exportData.formatConfig,
+      content,
+      format: exportData.format,
+      columns: exportData.columns,
+      rowCount: exportData.rows.length,
+    });
   }
 }
 

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

@@ -8,6 +8,7 @@ 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 { ReadOnlyError } = require("../server/utils/errors");
 const { errorMiddleware } = require("../server/utils/errors");
 
 function createConnection(id, label, databasePath) {
@@ -39,13 +40,59 @@ async function startApi(t) {
       serviceCalls.push(databaseId);
       return [{ name: "companies" }];
     },
+    executeRawQuery(databaseId, sql, options = {}) {
+      serviceCalls.push(`${databaseId}:query:${sql}:${options.storeName ?? ""}`);
+      if (sql === "READONLY") {
+        throw new ReadOnlyError("Cannot execute raw SQL against a read-only database.");
+      }
+      return {
+        result: {
+          sql,
+          statementCount: 1,
+          statements: [],
+          rows: [],
+          columns: [],
+          affectedRowCount: 0,
+          resultKind: "unknown",
+          timingMs: 2,
+          historyId: 42,
+          storedQuery: options.storeName
+            ? {
+                id: 42,
+                title: options.storeName,
+                isSaved: true,
+              }
+            : null,
+        },
+      };
+    },
   };
   const app = express();
 
   app.use(express.json());
   app.use(
     "/api/v1",
-    createExternalApiRouter({ databaseService, tokenService })
+    createExternalApiRouter({
+      databaseService,
+      tokenService,
+      appInfoService: async ({ port, url }) => ({
+        packageName: "sqlite-hub",
+        appVersion: "1.0.1",
+        sqliteVersion: "3.50.0",
+        port,
+        url,
+        versionCheck: {
+          packageName: "sqlite-hub",
+          currentVersion: "1.0.1",
+          latestVersion: "1.0.1",
+          updateAvailable: false,
+          checkedAt: "2026-06-20T10:00:00.000Z",
+          source: "npm",
+          releaseUrl: "https://www.npmjs.com/package/sqlite-hub/v/1.0.1",
+          status: "current",
+        },
+      }),
+    })
   );
   app.use(errorMiddleware);
 
@@ -125,3 +172,65 @@ test("tokens are hashed, deletable, and isolated per database", async (t) => {
     /invalid for this database/
   );
 });
+
+test("public API info returns app and version status without a token", async (t) => {
+  const fixture = await startApi(t);
+  const response = await fetch(`${fixture.baseUrl}/info`);
+  const payload = await response.json();
+
+  assert.equal(response.status, 200);
+  assert.equal(payload.data.packageName, "sqlite-hub");
+  assert.equal(payload.data.appVersion, "1.0.1");
+  assert.equal(payload.data.sqliteVersion, "3.50.0");
+  assert.equal(payload.data.versionCheck.status, "current");
+  assert.equal(payload.data.versionCheck.updateAvailable, false);
+  assert.match(payload.data.url, /^http:\/\/127\.0\.0\.1:\d+$/);
+});
+
+test("query API executes raw SQL with a database token", async (t) => {
+  const fixture = await startApi(t);
+  const created = fixture.tokenService.createToken(fixture.databaseA.id, "Automation");
+  const response = await fetch(`${fixture.baseUrl}/query`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${created.token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      databaseId: fixture.databaseA.id,
+      sql: "SELECT 1",
+      store: "Stored API Query",
+    }),
+  });
+  const payload = await response.json();
+
+  assert.equal(response.status, 200);
+  assert.equal(payload.data.sql, "SELECT 1");
+  assert.equal(payload.data.historyId, 42);
+  assert.equal(payload.data.storedQuery.title, "Stored API Query");
+  assert.equal(payload.metadata.stored, true);
+  assert.equal(payload.metadata.databaseId, fixture.databaseA.id);
+  assert.deepEqual(fixture.serviceCalls, [
+    `${fixture.databaseA.id}:query:SELECT 1:Stored API Query`,
+  ]);
+});
+
+test("query API rejects read-only raw SQL execution", async (t) => {
+  const fixture = await startApi(t);
+  const created = fixture.tokenService.createToken(fixture.databaseA.id, "Automation");
+  const response = await fetch(`${fixture.baseUrl}/query`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${created.token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      databaseId: fixture.databaseA.id,
+      sql: "READONLY",
+    }),
+  });
+  const payload = await response.json();
+
+  assert.equal(response.status, 403);
+  assert.equal(payload.error.code, "SQLITE_READONLY");
+});

package/tests/cli-args.test.js

@@ -31,6 +31,11 @@ test("parses database info commands with the new schema", () => {
   assert.equal(parseCliArguments(["--database:db", "--lastopened"]).lastOpenedInfo, true);
 });
 
+test("parses app info command and keeps config as a legacy alias", () => {
+  assert.equal(parseCliArguments(["--info"]).info, true);
+  assert.equal(parseCliArguments(["--config"]).info, true);
+});
+
 test("keeps old sqleditor aliases working", () => {
   const listOptions = parseCliArguments(["--database:Unit-00", "--sqleditor"]);
   const executeOptions = parseCliArguments(["--database:Unit-00", "--sqleditor:Saved Query"]);
@@ -50,8 +55,13 @@ test("keeps old database detail aliases working", () => {
   assert.equal(tableOptions.tables, true);
 });
 
-test("parses query display and export commands", () => {
-  const showOptions = parseCliArguments(["--database:db", "--query:Stock Winners"]);
+test("parses raw query, store name, saved query display, and export commands", () => {
+  const rawOptions = parseCliArguments([
+    "--database:db",
+    "--query:SELECT 1",
+    "--store:Stored Select",
+  ]);
+  const showOptions = parseCliArguments(["--database:db", "--saved-query:Stock Winners"]);
   const notesOptions = parseCliArguments(["--database:db", "--notes:Stock Winners"]);
   const exportOptions = parseCliArguments([
     "--database:db",
@@ -59,6 +69,8 @@ test("parses query display and export commands", () => {
     "--format:md",
   ]);
 
+  assert.equal(rawOptions.rawQuery, "SELECT 1");
+  assert.equal(rawOptions.storeName, "Stored Select");
   assert.equal(showOptions.showQuery, "Stock Winners");
   assert.equal(notesOptions.showNotes, "Stock Winners");
   assert.equal(exportOptions.exportTarget, "Stock Winners");
@@ -96,5 +108,6 @@ test("parses document commands", () => {
 test("validates export formats", () => {
   assert.equal(normalizeExportFormat("csv"), "csv");
   assert.equal(normalizeExportFormat("TSV"), "tsv");
-  assert.throws(() => normalizeExportFormat("json"), /Unsupported export format/);
+  assert.equal(normalizeExportFormat("json"), "json");
+  assert.throws(() => normalizeExportFormat("xlsx"), /Unsupported export format/);
 });

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

@@ -8,7 +8,7 @@ const Database = require("better-sqlite3");
 const { DatabaseCommandService } = require("../server/services/databaseCommandService");
 const { AppStateStore } = require("../server/services/storage/appStateStore");
 
-function createFixture(t) {
+function createFixture(t, options = {}) {
   const directory = fs.mkdtempSync(path.join(os.tmpdir(), "sqlite-hub-command-service-"));
   const databasePath = path.join(directory, "sample.db");
   const targetDb = new Database(databasePath);
@@ -27,7 +27,7 @@ function createFixture(t) {
     lastOpenedAt: new Date().toISOString(),
     lastModifiedAt: new Date().toISOString(),
     sizeBytes: fs.statSync(databasePath).size,
-    readOnly: false,
+    readOnly: Boolean(options.readOnly),
     logoPath: null,
   };
 
@@ -72,6 +72,7 @@ function createFixture(t) {
   return {
     connection,
     service: new DatabaseCommandService({ appStateStore: store }),
+    store,
   };
 }
 
@@ -100,3 +101,39 @@ test("database command service provides shared CLI and API operations", (t) => {
   assert.equal(service.listDocuments(connection.id).length, 1);
   assert.equal(service.getDocument(connection.id, "Readme").content, "# Sample\n");
 });
+
+test("raw query execution writes SQL Editor query history", (t) => {
+  const { connection, service, store } = createFixture(t);
+  const beforeCount = Number(
+    store.db.prepare("SELECT COUNT(*) AS count FROM query_history").get().count
+  );
+  const { result, storedQuery } = service.executeRawQuery(
+    connection.id,
+    "INSERT INTO companies (name) VALUES ('Initech')",
+    { storeName: "Add Initech" }
+  );
+  const afterCount = Number(
+    store.db.prepare("SELECT COUNT(*) AS count FROM query_history").get().count
+  );
+  const historyRow = store.db
+    .prepare("SELECT raw_sql, query_type, title, is_saved FROM query_history WHERE id = ?")
+    .get(result.historyId);
+
+  assert.equal(result.affectedRowCount, 1);
+  assert.equal(afterCount, beforeCount + 1);
+  assert.equal(historyRow.raw_sql, "INSERT INTO companies (name) VALUES ('Initech')");
+  assert.equal(historyRow.query_type, "insert");
+  assert.equal(historyRow.title, "Add Initech");
+  assert.equal(historyRow.is_saved, 1);
+  assert.equal(storedQuery.title, "Add Initech");
+  assert.equal(storedQuery.isSaved, true);
+});
+
+test("raw query execution is blocked for read-only connections", (t) => {
+  const { connection, service } = createFixture(t, { readOnly: true });
+
+  assert.throws(
+    () => service.executeRawQuery(connection.id, "SELECT 1"),
+    /read-only database/
+  );
+});