bunqueue-dashboard 0.0.35 → 0.0.36

package/agent/db/schema.ts

@@ -0,0 +1,79 @@
+import { ident, knownTable, openDb } from './core';
+import type { DbInfo, DbTableSchema } from './types';
+
+/** Column definitions, indexes and original DDL for one table. */
+export function dbSchema(path: string, table: string): DbTableSchema {
+  const db = openDb(path);
+  try {
+    const name = knownTable(db, table);
+    const columns = (
+      db.query(`PRAGMA table_info(${ident(name)})`).all() as {
+        name: string;
+        type: string;
+        notnull: number;
+        dflt_value: string | null;
+        pk: number;
+      }[]
+    ).map((column) => ({
+      name: column.name,
+      type: column.type || 'ANY',
+      notNull: column.notnull === 1,
+      defaultValue: column.dflt_value,
+      primaryKey: column.pk > 0,
+    }));
+    const indexes = (
+      db.query(`PRAGMA index_list(${ident(name)})`).all() as { name: string; unique: number }[]
+    ).map((index) => ({
+      name: index.name,
+      unique: index.unique === 1,
+      columns: (
+        db.query(`PRAGMA index_info(${ident(index.name)})`).all() as { name: string }[]
+      ).map((column) => column.name),
+    }));
+    const master = db
+      .query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?")
+      .get(name) as { sql: string | null } | null;
+    const { c: rowCount } = db.query(`SELECT COUNT(*) AS c FROM ${ident(name)}`).get() as {
+      c: number;
+    };
+    return { table: name, columns, indexes, sql: master?.sql ?? null, rowCount };
+  } finally {
+    db.close();
+  }
+}
+
+/** Store-level metadata: engine version, pragmas, object counts, on-disk size. */
+export function dbInfo(path: string): DbInfo {
+  const db = openDb(path);
+  try {
+    const one = (sql: string) => (db.query(sql).values()[0] as unknown[])[0];
+    const count = (type: string) =>
+      (
+        db
+          .query(
+            "SELECT COUNT(*) AS c FROM sqlite_master WHERE type = ? AND name NOT LIKE 'sqlite_%'"
+          )
+          .get(type) as { c: number }
+      ).c;
+    const size = (file: string) => {
+      try {
+        return Bun.file(file).size || 0;
+      } catch {
+        return 0;
+      }
+    };
+    return {
+      sqliteVersion: String(one('SELECT sqlite_version()')),
+      pageSize: Number(one('PRAGMA page_size')),
+      pageCount: Number(one('PRAGMA page_count')),
+      journalMode: String(one('PRAGMA journal_mode')),
+      freelistPages: Number(one('PRAGMA freelist_count')),
+      tables: count('table'),
+      indexes: count('index'),
+      fileSize: size(path),
+      walSize: size(`${path}-wal`),
+    };
+  } finally {
+    db.close();
+  }
+}

package/agent/db/tables.ts

@@ -0,0 +1,157 @@
+import {
+  bigintCell,
+  boundRowid,
+  buildFilter,
+  ident,
+  isTruncated,
+  knownTable,
+  openDb,
+  safeIntegers,
+  sanitize,
+} from './core';
+import {
+  MAX_FULL_CELL,
+  MAX_ROWS,
+  type DbFilter,
+  type DbRowId,
+  type DbRowsOptions,
+  type DbRowsPage,
+  type DbTableInfo,
+} from './types';
+
+/** All user tables with row + column counts. */
+export function dbTables(path: string): DbTableInfo[] {
+  const db = openDb(path);
+  try {
+    const tables = db
+      .query(
+        "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+      )
+      .all() as { name: string }[];
+    return tables.map(({ name }) => {
+      const { c } = db.query(`SELECT COUNT(*) AS c FROM ${ident(name)}`).get() as { c: number };
+      const columns = db.query(`PRAGMA table_info(${ident(name)})`).all();
+      return { name, rows: c, columns: columns.length };
+    });
+  } finally {
+    db.close();
+  }
+}
+
+/** One page of a table's rows from a single SQLite snapshot. */
+export function dbRows(
+  path: string,
+  table: string,
+  limit: number,
+  offset: number,
+  orderBy?: string,
+  dir: 'asc' | 'desc' = 'asc',
+  filter?: DbFilter,
+  options: Readonly<DbRowsOptions> = {}
+): DbRowsPage {
+  const boundedLimit = Math.max(1, Math.min(MAX_ROWS, Math.floor(limit) || 50));
+  const boundedOffset = Number.isFinite(offset)
+    ? Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.floor(offset) || 0))
+    : 0;
+  const db = openDb(path);
+  try {
+    const snapshot = db.transaction((): DbRowsPage => {
+      const name = knownTable(db, table);
+      const columns = (
+        db.query(`PRAGMA table_info(${ident(name)})`).all() as { name: string }[]
+      ).map((column) => column.name);
+
+      let order = '';
+      let sortColumn: string | null = null;
+      if (orderBy) {
+        sortColumn = columns.find((column) => column === orderBy) ?? null;
+        if (!sortColumn) throw new Error(`No such column: ${orderBy}`);
+        order = ` ORDER BY ${ident(sortColumn)} ${dir === 'desc' ? 'DESC' : 'ASC'}`;
+      }
+      const { clause, params, applied } = buildFilter(columns, filter);
+      const { c: total } = db
+        .query(`SELECT COUNT(*) AS c FROM ${ident(name)}${clause}`)
+        .get(...(params as [])) as { c: number };
+      options.afterCount?.();
+
+      let rowids: (DbRowId | null)[] = [];
+      let rawRows: unknown[][];
+      try {
+        const statement = db.query(
+          `SELECT rowid AS __rid, * FROM ${ident(name)}${clause}${order} LIMIT ? OFFSET ?`
+        );
+        safeIntegers(statement);
+        const rows = statement.values(...(params as []), boundedLimit, boundedOffset) as unknown[][];
+        rowids = rows.map((row) =>
+          typeof row[0] === 'bigint'
+            ? bigintCell(row[0])
+            : typeof row[0] === 'number' && Number.isSafeInteger(row[0])
+              ? row[0]
+              : null
+        );
+        rawRows = rows.map((row) => row.slice(1));
+      } catch {
+        const statement = db.query(
+          `SELECT * FROM ${ident(name)}${clause}${order} LIMIT ? OFFSET ?`
+        );
+        safeIntegers(statement);
+        rawRows = statement.values(
+          ...(params as []),
+          boundedLimit,
+          boundedOffset
+        ) as unknown[][];
+        rowids = rawRows.map(() => null);
+      }
+
+      return {
+        table: name,
+        columns,
+        rows: sanitize(rawRows),
+        rowids,
+        truncatedCells: rawRows.map((row) => row.map(isTruncated)),
+        total,
+        limit: boundedLimit,
+        offset: boundedOffset,
+        orderBy: sortColumn,
+        dir: dir === 'desc' ? 'desc' : 'asc',
+        filter: applied,
+      };
+    });
+    return snapshot.deferred();
+  } finally {
+    db.close();
+  }
+}
+
+/** Full, untruncated value of a single cell, keyed by rowid. */
+export function dbCell(
+  path: string,
+  table: string,
+  rowid: DbRowId,
+  column: string
+): { value: unknown } {
+  const db = openDb(path);
+  try {
+    const name = knownTable(db, table);
+    const columns = (
+      db.query(`PRAGMA table_info(${ident(name)})`).all() as { name: string }[]
+    ).map((entry) => entry.name);
+    const resolvedColumn = columns.find((entry) => entry === column);
+    if (!resolvedColumn) throw new Error(`No such column: ${column}`);
+    const statement = db.query(
+      `SELECT ${ident(resolvedColumn)} AS v FROM ${ident(name)} WHERE rowid = ?`
+    );
+    safeIntegers(statement);
+    const row = statement.get(boundRowid(rowid)) as { v: unknown } | null;
+    if (!row) throw new Error('Row not found');
+    let value = row.v;
+    if (value instanceof Uint8Array) value = `<blob ${value.byteLength} B — binary, not shown>`;
+    else if (typeof value === 'bigint') value = bigintCell(value);
+    else if (typeof value === 'string' && value.length > MAX_FULL_CELL) {
+      value = `${value.slice(0, MAX_FULL_CELL)}…`;
+    }
+    return { value };
+  } finally {
+    db.close();
+  }
+}

package/agent/db/types.ts

@@ -0,0 +1,118 @@
+/** Hard cap on rows returned by any endpoint. */
+export const MAX_ROWS = 500;
+/** Cell strings longer than this are truncated server-side. */
+export const MAX_CELL = 2000;
+/** Full single-cell fetch hard cap. */
+export const MAX_FULL_CELL = 1_000_000;
+export const DB_EXPORT_MAX_ROWS = 200_000;
+export const DB_EXPORT_MAX_BYTES = 16 * 1024 * 1024;
+export const DB_EXPORT_MAX_COLUMNS = 256;
+export const DB_EXPORT_MAX_IDENTIFIER_CHARS = 1024;
+export const DB_EXPORT_MAX_FILTER_CHARS = 4096;
+export const DB_EXPORT_TIMEOUT_MS = 15_000;
+export const QUERY_TIMEOUT_MS = 5000;
+export const MAX_CONCURRENT_QUERIES = 2;
+export const MAX_CONCURRENT_EXPORTS = 1;
+
+/** Thrown when the database file does not exist yet (maps to HTTP 404). */
+export class MissingDbError extends Error {
+  readonly missing = true;
+}
+
+/** Maps a saturated export worker pool to HTTP 429. */
+export class DbExportBusyError extends Error {}
+
+/** Maps export worker startup/crash/timeout failures to HTTP 503. */
+export class DbExportUnavailableError extends Error {}
+
+export interface DbTableInfo {
+  name: string;
+  rows: number;
+  columns: number;
+}
+
+export interface DbFilter {
+  column: string;
+  op: 'contains' | 'eq' | 'ne';
+  value: string;
+}
+
+export interface DbRowsPage {
+  table: string;
+  columns: string[];
+  rows: unknown[][];
+  rowids: (DbRowId | null)[];
+  truncatedCells: boolean[][];
+  total: number;
+  limit: number;
+  offset: number;
+  orderBy: string | null;
+  dir: 'asc' | 'desc';
+  filter: DbFilter | null;
+}
+
+export type DbExportCap = 'rows' | 'bytes' | null;
+
+export interface DbCsvExport {
+  table: string;
+  content: Uint8Array<ArrayBuffer>;
+  rowCount: number;
+  bytes: number;
+  cap: DbExportCap;
+}
+
+/** Tests may lower a cap, but callers can never raise the production ceiling. */
+export interface DbExportLimits {
+  maxRows?: number;
+  maxBytes?: number;
+  onSnapshot?: () => void;
+}
+
+export interface DbRowsOptions {
+  afterCount?: () => void;
+}
+
+/** JSON/query-string-safe SQLite rowid. */
+export type DbRowId = number | string;
+
+export interface DbColumnInfo {
+  name: string;
+  type: string;
+  notNull: boolean;
+  defaultValue: string | null;
+  primaryKey: boolean;
+}
+
+export interface DbIndexInfo {
+  name: string;
+  unique: boolean;
+  columns: string[];
+}
+
+export interface DbTableSchema {
+  table: string;
+  columns: DbColumnInfo[];
+  indexes: DbIndexInfo[];
+  sql: string | null;
+  rowCount: number;
+}
+
+export interface DbInfo {
+  sqliteVersion: string;
+  pageSize: number;
+  pageCount: number;
+  journalMode: string;
+  freelistPages: number;
+  tables: number;
+  indexes: number;
+  fileSize: number;
+  walSize: number;
+}
+
+export interface DbQueryResult {
+  columns: string[];
+  rows: unknown[][];
+  rowCount: number;
+  truncated: boolean;
+  ms: number;
+}

package/agent/db/workerFactory.ts

@@ -0,0 +1,25 @@
+let workerUrl = new URL('../dbQueryWorker.ts', import.meta.url).href;
+
+const spawnWorker = (): Worker => new Worker(workerUrl, { type: 'module' });
+let queryFactory: () => Worker = spawnWorker;
+let exportFactory: () => Worker = spawnWorker;
+
+export function createQueryWorker(): Worker {
+  return queryFactory();
+}
+
+export function createExportWorker(): Worker {
+  return exportFactory();
+}
+
+export function setQueryWorkerUrl(url: string): void {
+  workerUrl = url;
+}
+
+export function setQueryWorkerFactory(factory: (() => Worker) | null): void {
+  queryFactory = factory ?? spawnWorker;
+}
+
+export function setExportWorkerFactory(factory: (() => Worker) | null): void {
+  exportFactory = factory ?? spawnWorker;
+}