dbn-cli 0.3.0 → 0.5.2

package/README.md

@@ -1,4 +1,4 @@
-# dbn
+# dbn - DB Navigator
 
 A lightweight terminal SQLite browser with an ncdu-style interface.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbn-cli",
-  "version": "0.3.0",
+  "version": "0.5.2",
   "description": "A lightweight terminal-based database browser",
   "repository": "https://github.com/amio/dbn-cli",
   "type": "module",
@@ -9,10 +9,10 @@
     "dbn": "bin/dbn.ts"
   },
   "scripts": {
-    "test": "node --test --experimental-strip-types test/*.test.ts",
-    "test:watch": "node --test --watch --experimental-strip-types test/*.test.ts",
-    "test:coverage": "node --test --experimental-test-coverage --experimental-strip-types test/*.test.ts",
-    "dev": "node bin/dbp.ts"
+    "test": "node --test --experimental-strip-types src/**/*.test.ts src/*.test.ts",
+    "test:watch": "node --test --watch --experimental-strip-types src/**/*.test.ts src/*.test.ts",
+    "test:coverage": "node --test --experimental-test-coverage --experimental-strip-types src/**/*.test.ts src/*.test.ts",
+    "dev": "node bin/dbn.ts"
   },
   "keywords": [
     "database",

package/src/adapter/adapter.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { DatabaseSync } from 'node:sqlite';
+import { existsSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteAdapter } from '../adapter/sqlite.ts';
+
+const TEST_DB = join(tmpdir(), 'dbn-cli-test.db');
+
+/**
+ * Set up test database
+ */
+function setupTestDB(): void {
+  // Remove old test db if exists
+  if (existsSync(TEST_DB)) {
+    unlinkSync(TEST_DB);
+  }
+
+  // Create test database
+  const db = new DatabaseSync(TEST_DB);
+  
+  // Create test tables
+  db.exec(`
+    CREATE TABLE users (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      email TEXT,
+      age INTEGER
+    );
+  `);
+
+  db.exec(`
+    CREATE TABLE posts (
+      id INTEGER PRIMARY KEY,
+      user_id INTEGER,
+      title TEXT NOT NULL,
+      content TEXT,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+
+  // Insert test data
+  const insertUser = db.prepare('INSERT INTO users (name, email, age) VALUES (?, ?, ?)');
+  insertUser.run('Alice', 'alice@example.com', 30);
+  insertUser.run('Bob', 'bob@example.com', 25);
+  insertUser.run('Charlie', 'charlie@example.com', 35);
+
+  const insertPost = db.prepare('INSERT INTO posts (user_id, title, content) VALUES (?, ?, ?)');
+  insertPost.run(1, 'Hello World', 'This is my first post');
+  insertPost.run(1, 'Second Post', 'Another post by Alice');
+  insertPost.run(2, 'Bobs Post', 'Post by Bob');
+
+  db.close();
+}
+
+/**
+ * Clean up test database
+ */
+function cleanupTestDB(): void {
+  if (existsSync(TEST_DB)) {
+    unlinkSync(TEST_DB);
+  }
+}
+
+/**
+ * Test suite for SQLiteAdapter
+ */
+describe('SQLiteAdapter', () => {
+  before(() => {
+    setupTestDB();
+  });
+
+  after(() => {
+    cleanupTestDB();
+  });
+
+  it('should connect to database', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    assert.ok((adapter as any).db !== null, 'Database should be connected');
+    assert.strictEqual((adapter as any).path, TEST_DB, 'Path should be set correctly');
+    adapter.close();
+  });
+
+  it('should throw error when connecting to invalid path', () => {
+    const adapter = new SQLiteAdapter();
+    // Try to connect to an invalid path (directory that doesn't exist)
+    assert.throws(
+      () => adapter.connect('/nonexistent/path/to/database.db'),
+      /Failed to open database/,
+      'Should throw error for invalid path'
+    );
+  });
+
+  it('should get all tables', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const tables = adapter.getTables();
+    assert.strictEqual(tables.length, 2, 'Should have 2 tables');
+    assert.strictEqual(tables[0].name, 'posts', 'First table should be posts');
+    assert.strictEqual(tables[1].name, 'users', 'Second table should be users');
+    assert.ok(tables[0].row_count !== undefined, 'Should have row_count property');
+    
+    adapter.close();
+  });
+
+  it('should get table schema', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const schema = adapter.getTableSchema('users');
+    assert.strictEqual(schema.length, 4, 'Users table should have 4 columns');
+    assert.strictEqual(schema[0].name, 'id', 'First column should be id');
+    assert.strictEqual(schema[0].type, 'INTEGER', 'ID should be INTEGER');
+    assert.strictEqual(schema[0].pk, 1, 'ID should be primary key');
+    assert.strictEqual(schema[1].name, 'name', 'Second column should be name');
+    assert.strictEqual(schema[1].type, 'TEXT', 'Name should be TEXT');
+    assert.strictEqual(schema[1].notnull, 1, 'Name should be NOT NULL');
+    
+    adapter.close();
+  });
+
+  it('should get table data', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const data = adapter.getTableData('users');
+    assert.strictEqual(data.length, 3, 'Should have 3 users');
+    assert.strictEqual(data[0].name, 'Alice', 'First user should be Alice');
+    assert.strictEqual(data[0].email, 'alice@example.com', 'Alice email should match');
+    assert.strictEqual(data[0].age, 30, 'Alice age should be 30');
+    
+    adapter.close();
+  });
+
+  it('should get table data with pagination', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    // Get 2 rows starting from offset 1
+    const data = adapter.getTableData('users', { limit: 2, offset: 1 });
+    assert.strictEqual(data.length, 2, 'Should return 2 users');
+    assert.strictEqual(data[0].name, 'Bob', 'First result should be Bob');
+    assert.strictEqual(data[1].name, 'Charlie', 'Second result should be Charlie');
+    
+    adapter.close();
+  });
+
+  it('should get table data with custom limit', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const data = adapter.getTableData('users', { limit: 1 });
+    assert.strictEqual(data.length, 1, 'Should return 1 user');
+    assert.strictEqual(data[0].name, 'Alice', 'Should return Alice');
+    
+    adapter.close();
+  });
+
+  it('should get row count', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    
+    const userCount = adapter.getRowCount('users');
+    assert.strictEqual(userCount, 3, 'Should have 3 users');
+    
+    const postCount = adapter.getRowCount('posts');
+    assert.strictEqual(postCount, 3, 'Should have 3 posts');
+    
+    adapter.close();
+  });
+
+  it('should close database connection', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+    assert.ok((adapter as any).db !== null, 'Database should be connected');
+    
+    adapter.close();
+    assert.strictEqual((adapter as any).db, null, 'Database should be null after close');
+  });
+
+  it('should handle closing when not connected', () => {
+    const adapter = new SQLiteAdapter();
+    assert.doesNotThrow(() => adapter.close(), 'Should not throw when closing unconnected adapter');
+  });
+
+  it('should delete a row', () => {
+    const adapter = new SQLiteAdapter();
+    adapter.connect(TEST_DB);
+
+    const initialCount = adapter.getRowCount('users');
+    const user = adapter.getTableData('users', { limit: 1, offset: 0 })[0];
+    assert.ok(user.id, 'User should have an id');
+
+    adapter.deleteRow('users', { id: user.id });
+
+    const newCount = adapter.getRowCount('users');
+    assert.strictEqual(newCount, initialCount - 1, 'Row count should decrease by 1');
+
+    const remainingUsers = adapter.getTableData('users');
+    assert.ok(!remainingUsers.find(u => u.id === user.id), 'Deleted user should not be in results');
+
+    adapter.close();
+  });
+});

package/src/adapter/base.ts

@@ -1,4 +1,4 @@
-import type { TableInfo, ColumnSchema, QueryOptions } from '../types.ts';
+import type { TableInfo, ColumnSchema, QueryOptions, HealthInfo } from '../types.ts';
 
 /**
  * Base class for database adapters
@@ -39,6 +39,19 @@ export abstract class DatabaseAdapter {
    */
   abstract getRowCount(tableName: string): number;
 
+  /**
+   * Delete a single row from a table by its primary key values
+   * @param tableName - Name of the table
+   * @param keyValues - Primary key column/value mapping
+   */
+  abstract deleteRow(tableName: string, keyValues: Record<string, any>): void;
+
+  /**
+   * Get core database health info
+   * @returns Health information
+   */
+  abstract getHealthInfo(): HealthInfo;
+
   /**
    * Close the database connection
    */

package/src/adapter/sqlite.ts

@@ -1,6 +1,6 @@
 import { DatabaseSync } from 'node:sqlite';
 import { DatabaseAdapter } from './base.ts';
-import type { TableInfo, ColumnSchema, QueryOptions } from '../types.ts';
+import type { TableInfo, ColumnSchema, QueryOptions, HealthInfo } from '../types.ts';
 
 /**
  * SQLite adapter using Node.js 22+ built-in node:sqlite
@@ -98,6 +98,76 @@ export class SQLiteAdapter extends DatabaseAdapter {
     return result.count;
   }
 
+  /**
+   * Delete a single row from a table by its primary key values
+   * @param tableName - Name of the table
+   * @param keyValues - Primary key column/value mapping
+   */
+  deleteRow(tableName: string, keyValues: Record<string, any>): void {
+    if (!this.db) {
+      throw new Error('Database not connected');
+    }
+
+    const keys = Object.keys(keyValues);
+    if (keys.length === 0) {
+      throw new Error(`No primary key values provided for delete on ${tableName}`);
+    }
+
+    const conditions: string[] = [];
+    const values: any[] = [];
+
+    for (const key of keys) {
+      const value = keyValues[key];
+      if (value === null || value === undefined) {
+        conditions.push(`"${key}" IS NULL`);
+      } else {
+        conditions.push(`"${key}" = ?`);
+        values.push(value);
+      }
+    }
+
+    const whereClause = conditions.join(' AND ');
+    const stmt = this.db.prepare(`DELETE FROM "${tableName}" WHERE ${whereClause}`);
+    stmt.run(...values);
+  }
+
+  /**
+   * Get core database health info
+   */
+  getHealthInfo(): HealthInfo {
+    if (!this.db) {
+      throw new Error('Database not connected');
+    }
+
+    const singleValue = <T = string>(sql: string): T => {
+      const stmt = this.db!.prepare(sql);
+      const row = stmt.get() as Record<string, any> | undefined;
+      if (!row) return '' as T;
+      const value = Object.values(row)[0];
+      return value as T;
+    };
+
+    return {
+      sqlite_version: singleValue<string>('SELECT sqlite_version()'),
+      journal_mode: singleValue<string>('PRAGMA journal_mode'),
+      synchronous: String(singleValue<number>('PRAGMA synchronous')),
+      locking_mode: singleValue<string>('PRAGMA locking_mode'),
+      page_size: singleValue<number>('PRAGMA page_size'),
+      page_count: singleValue<number>('PRAGMA page_count'),
+      freelist_count: singleValue<number>('PRAGMA freelist_count'),
+      cache_size: singleValue<number>('PRAGMA cache_size'),
+      wal_autocheckpoint: singleValue<number>('PRAGMA wal_autocheckpoint'),
+      auto_vacuum: String(singleValue<number>('PRAGMA auto_vacuum')),
+      user_version: singleValue<number>('PRAGMA user_version'),
+      application_id: singleValue<number>('PRAGMA application_id'),
+      encoding: singleValue<string>('PRAGMA encoding'),
+      foreign_keys: String(singleValue<number>('PRAGMA foreign_keys')),
+      temp_store: String(singleValue<number>('PRAGMA temp_store')),
+      mmap_size: singleValue<number>('PRAGMA mmap_size'),
+      busy_timeout: singleValue<number>('PRAGMA busy_timeout')
+    };
+  }
+
   /**
    * Close the database connection
    */

package/src/index.ts

@@ -86,7 +86,9 @@ export class DBPeek {
    */
   private setupInput(): void {
     // Enable raw mode for key-by-key input
-    stdin.setRawMode(true);
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
     stdin.resume();
     stdin.setEncoding('utf8');
 
@@ -112,6 +114,25 @@ export class DBPeek {
       return;
     }
 
+    if (key.name === 'y' && this.navigator.hasPendingDelete()) {
+      this.navigator.confirmDelete();
+      this.render();
+      return;
+    }
+
+    if (
+      this.navigator.hasPendingDelete() &&
+      (key.name === 'escape' || key.name === 'h' || key.name === 'left')
+    ) {
+      this.navigator.cancelDelete();
+      this.render();
+      return;
+    }
+
+    if (this.navigator.hasPendingDelete()) {
+      return;
+    }
+
     // Handle different keys
     switch (key.name) {
       case 'q':
@@ -119,12 +140,28 @@ export class DBPeek {
         break;
 
       case 'j':
+        if (this.navigator.getState().type === 'row-detail') {
+          (this.navigator as any).nextRecord();
+        } else {
+          this.navigator.moveDown();
+        }
+        this.render();
+        break;
+
+      case 'k':
+        if (this.navigator.getState().type === 'row-detail') {
+          (this.navigator as any).prevRecord();
+        } else {
+          this.navigator.moveUp();
+        }
+        this.render();
+        break;
+
       case 'down':
         this.navigator.moveDown();
         this.render();
         break;
 
-      case 'k':
       case 'up':
         this.navigator.moveUp();
         this.render();
@@ -161,6 +198,15 @@ export class DBPeek {
         this.render();
         break;
 
+      case 'backspace': {
+        const deleteState = this.navigator.getState();
+        if (deleteState.type === 'table-detail' || deleteState.type === 'row-detail') {
+          this.navigator.requestDelete();
+          this.render();
+        }
+        break;
+      }
+
       case 's':
         // Toggle schema view in full screen mode
         const currentState = this.navigator.getState();
@@ -172,6 +218,17 @@ export class DBPeek {
           this.render();
         }
         break;
+
+      case 'i':
+        // Toggle core health overview
+        const infoState = this.navigator.getState();
+        if (infoState.type === 'health') {
+          this.navigator.back();
+        } else if (infoState.type === 'tables') {
+          this.navigator.viewHealth();
+        }
+        this.render();
+        break;
     }
   }
 

package/src/repro_bug.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { DatabaseSync } from 'node:sqlite';
+import { unlinkSync, existsSync } from 'node:fs';
+import { SQLiteAdapter } from './adapter/sqlite.ts';
+import { Navigator } from './ui/navigator.ts';
+
+const REPRO_DB = './repro-bug.db';
+
+describe('Navigator Bug Reproduction & Edge Cases', () => {
+  let adapter: SQLiteAdapter;
+  let navigator: Navigator;
+
+  before(() => {
+    const db = new DatabaseSync(REPRO_DB);
+    db.exec(`
+      CREATE TABLE items (
+        id INTEGER PRIMARY KEY,
+        name TEXT
+      );
+    `);
+
+    const insert = db.prepare('INSERT INTO items (name) VALUES (?)');
+    for (let i = 1; i <= 100; i++) {
+      insert.run(`Item ${i}`);
+    }
+    db.close();
+
+    adapter = new SQLiteAdapter();
+    adapter.connect(REPRO_DB);
+    navigator = new Navigator(adapter);
+  });
+
+  after(() => {
+    adapter.close();
+    if (existsSync(REPRO_DB)) {
+      unlinkSync(REPRO_DB);
+    }
+  });
+
+  it('should enter the correct row when scrolled down', () => {
+    navigator.init();
+    // Enter table detail for 'items'
+    navigator.enter();
+
+    let state = navigator.getState() as any;
+    assert.strictEqual(state.type, 'table-detail');
+    assert.strictEqual(state.dataCursor, 0);
+    assert.strictEqual(state.dataOffset, 0);
+
+    // Move down 30 times.
+    // Default visibleRows is 20, so this should push dataOffset to 11 (if cursor hits bottom at 19)
+    for (let i = 0; i < 30; i++) {
+      navigator.moveDown();
+    }
+
+    state = navigator.getState() as any;
+    const expectedRowIndex = state.dataOffset + state.dataCursor;
+    const expectedName = `Item ${expectedRowIndex + 1}`;
+
+    navigator.enter(); // Enter row detail
+    const rowState = navigator.getState() as any;
+
+    assert.strictEqual(rowState.type, 'row-detail');
+    assert.strictEqual(rowState.rowIndex, expectedRowIndex, `Row index should be ${expectedRowIndex}`);
+    assert.strictEqual(rowState.row.name, expectedName, `Row name should be ${expectedName}`);
+  });
+
+  it('should handle jumping to bottom and moving up', () => {
+    navigator.init();
+    navigator.enter();
+
+    navigator.jumpToBottom();
+    let state = navigator.getState() as any;
+    assert.strictEqual(state.dataOffset + state.dataCursor, 99);
+
+    navigator.moveUp();
+    state = navigator.getState() as any;
+    assert.strictEqual(state.dataOffset + state.dataCursor, 98);
+
+    navigator.enter();
+    const rowState = navigator.getState() as any;
+    assert.strictEqual(rowState.row.name, 'Item 99');
+    assert.strictEqual(rowState.rowIndex, 98);
+  });
+
+  it('should handle jumping to top after scrolling', () => {
+    navigator.init();
+    navigator.enter();
+
+    for (let i = 0; i < 50; i++) navigator.moveDown();
+    navigator.jumpToTop();
+
+    let state = navigator.getState() as any;
+    assert.strictEqual(state.dataOffset, 0);
+    assert.strictEqual(state.dataCursor, 0);
+
+    const selectedRow = (navigator as any).getSelectedRow(state);
+    assert.strictEqual(selectedRow.name, 'Item 1');
+  });
+});

package/src/types.ts

@@ -30,6 +30,39 @@ export interface QueryOptions {
   offset?: number;
 }
 
+/**
+ * Core database health overview info
+ */
+export interface HealthInfo {
+  sqlite_version: string;
+  journal_mode: string;
+  synchronous: string;
+  locking_mode: string;
+  page_size: number;
+  page_count: number;
+  freelist_count: number;
+  cache_size: number;
+  wal_autocheckpoint: number;
+  auto_vacuum: string;
+  user_version: number;
+  application_id: number;
+  encoding: string;
+  foreign_keys: string;
+  temp_store: string;
+  mmap_size: number;
+  busy_timeout: number;
+}
+
+/**
+ * Delete confirmation state for write actions
+ */
+export interface DeleteConfirmationState {
+  tableName: string;
+  rowIndex: number;
+  keyValues: Record<string, any>;
+  step: 1 | 2;
+}
+
 /**
  * Base view state properties
  */
@@ -58,8 +91,14 @@ export interface TableDetailViewState extends BaseViewState {
   totalRows: number;
   dataOffset: number;
   dataCursor: number;
+  bufferOffset: number;
   visibleRows: number;
   showSchema?: boolean;
+  deleteConfirm?: DeleteConfirmationState;
+  notice?: string;
+  columnWeights?: number[];
+  cachedColWidths?: number[];
+  cachedScreenWidth?: number;
 }
 
 /**
@@ -81,13 +120,27 @@ export interface RowDetailViewState extends BaseViewState {
   tableName: string;
   row: Record<string, any>;
   rowIndex: number;
+  totalRows: number;
   schema: ColumnSchema[];
+  scrollOffset: number;
+  totalLines: number;
+  visibleHeight: number;
+  deleteConfirm?: DeleteConfirmationState;
+  notice?: string;
+}
+
+/**
+ * Health overview view state
+ */
+export interface HealthViewState extends BaseViewState {
+  type: 'health';
+  info: HealthInfo;
 }
 
 /**
  * Union type for all possible view states
  */
-export type ViewState = TablesViewState | TableDetailViewState | SchemaViewState | RowDetailViewState;
+export type ViewState = TablesViewState | TableDetailViewState | SchemaViewState | RowDetailViewState | HealthViewState;
 
 /**
  * Screen dimensions

package/src/ui/grit/README.md

@@ -0,0 +1,58 @@
+# GRIT (Grid-TUI)
+
+GRIT is a lightweight TUI layout library built for Node.js. It focuses on a modern "OpenCode" aesthetic using solid background blocks and Unicode half-height characters for smooth transitions, rather than traditional box-drawing characters.
+
+## Design Philosophy
+
+- **Grid-based**: Everything is a grid or a box.
+- **No Lines**: Uses background colors and Unicode blocks (`▀`, `▄`) for visual separation.
+- **TrueColor**: Native support for 24-bit ANSI colors.
+- **Width-Aware**: Correctly handles CJK characters and emojis.
+
+## API
+
+### `Box`
+
+A container that handles background color, padding, and alignment.
+
+```typescript
+import { Box } from './grit/index.ts';
+
+const box = new Box({
+  width: 80,
+  background: '#1A1A1A',
+  padding: 1
+});
+
+const line = box.render("Hello World", { align: 'center' });
+```
+
+### `Transition`
+
+Creates a half-height vertical transition between two background colors.
+
+```typescript
+import { Transition } from './grit/index.ts';
+
+// Top half is #1A1A1A, bottom half is #0D0D0D
+const line = Transition.draw(80, '#1A1A1A', '#0D0D0D');
+```
+
+### `Grid`
+
+Calculates weighted column widths for tabular layouts.
+
+```typescript
+import { Grid } from './grit/index.ts';
+
+const columns = Grid.calculateWidths(100, [
+  { weight: 1 }, // Flexible
+  { weight: 2 }, // Twice as wide
+  { minWidth: 10 } // Fixed minimum
+]);
+```
+
+## Internal Utilities
+
+- `ANSI`: Low-level ANSI escape sequence generators.
+- `wrapAnsiBg`: Helper to persist background colors across ANSI resets.