admindb 1.0.3 → 1.1.0

package/README.md

@@ -9,10 +9,11 @@
 
 
 A browser-based SQLite database administration tool. Manage a SQLite database
-entirely from the browser: browse tables, full CRUD, a visual table designer, an
-arbitrary SQL query runner, saved named queries, SQL-dump export, a
-"generate SQL" preview mode that never executes, a schema editor, and
-multi-database support.
+entirely from the browser: browse tables with full CRUD, inline
+spreadsheet-style grid editing, type-aware filters, bulk row operations, a
+visual table designer, an arbitrary SQL query runner, saved named queries,
+SQL-dump export, a "generate SQL" preview mode that never executes, a schema
+editor, and multi-database support.
 
 - **Backend:** Node.js + TypeScript (compiled to plain JS) on Express.
 - **Frontend:** Handlebars server-rendered templates, Tailwind CSS + DaisyUI,
@@ -132,10 +133,18 @@ In multi-db mode:
 ## Features
 
 - Browse every table and its rows (paginated, with primary-key awareness).
-- **Filter rows by column** — exact (`=value`), comparison (`>5`, `<=10`), prefix
-  (`pre*`) or substring (plain text) matching; filters survive sorting and
-  pagination.
-- Insert, edit, and delete rows (full CRUD). FK columns become dropdowns.
+- **Filter rows by column** — type-aware, per-column filter controls: foreign-key
+  dropdowns, boolean toggles, date and numeric range inputs, plus the exact
+  (`=value`), comparison (`>5`, `<=10`), prefix (`pre*`) and substring (plain
+  text) operators on text columns. Filters survive sorting and pagination.
+- **Inline (spreadsheet-style) editing** — double-click any cell to edit it in
+  place with a type-aware control (FK dropdown, boolean toggle, date picker,
+  number/text input). Changes are staged and highlighted in the grid, then
+  applied all at once in a single transaction, or discarded.
+- Insert and delete rows (full CRUD). FK columns become dropdowns.
+- **Bulk row operations** — select rows with checkboxes (or "select all"), then
+  **delete** them in one transaction (with a warning listing how many rows in
+  other tables reference them) or **export** only the selected rows as CSV/JSON.
 - **Export** table rows or query results as **CSV or JSON**, and **import a CSV
   file** (or pasted CSV) into a table.
 - Create tables visually: name, type, primary key, not-null / unique,
@@ -151,11 +160,10 @@ In multi-db mode:
 - **Indexes:** create indexes (plain or unique, on one or many columns — pick
   columns in order, with a live `CREATE INDEX` SQL preview) and drop them from
   the schema editor; automatic SQLite indexes are protected.
-- **Views:** create / drop `CREATE VIEW` definitions, preview the rows they
-  return, and inspect their SQL — from a dedicated Views page.
-- **Triggers:** create / drop triggers with a structured form (timing, single
-  event, optional `WHEN`, body with a live `CREATE TRIGGER` SQL preview) and
-  inspect existing trigger SQL — from a dedicated Triggers page.
+- **Related rows:** every table that has a foreign key pointing at a table gets
+  its own column at the end of that table's grid — each cell shows how many of
+  its rows reference that record; click it to open a nested table with all of
+  the referencing table's columns and data for that specific record.
 - **Read-only mode:** open the database(s) without write access — the file is
   opened `SQLITE_OPEN_READONLY` + `query_only`, every write route returns `403`,
   and the UI hides/disables all write controls and shows a banner.
@@ -229,15 +237,19 @@ $env:DB_DIR='./db'; npm start                 # PowerShell
 | GET    | `/api/tables`                            | List tables                      |
 | GET    | `/api/tables/:table/info`                | Column + FK metadata, PK columns |
 | GET    | `/api/tables/:table/fk-options`          | Values for FK dropdowns          |
-| GET    | `/api/tables/:table/rows?page&limit&f`   | Paginated rows (`f` = URL-encoded JSON filters, e.g. `{"age":">35"}`) |
+| GET    | `/api/tables/:table/rows?page&limit&f`   | Paginated rows (`f` = URL-encoded JSON filters — legacy strings like `{"age":">35"}` or structured conditions like `{"balance":{"op":"gte","value":"100"}}`) |
 | GET    | `/api/tables/:table/row/:id`             | Single row by (encoded) PK       |
 | POST   | `/api/tables/:table/rows`                | Insert row                       |
 | POST   | `/api/tables/:table/rows/generate`       | Generate INSERT SQL (no execute) |
 | POST   | `/api/tables/:table/rows/import`         | Import CSV (`{ csv }`, header row must match columns) |
 | GET    | `/api/tables/:table/export?format=`      | Download all rows as `csv` or `json` |
-| PUT    | `/api/tables/:table/row/:id`             | Update row                       |
+| PUT    | `/api/tables/:table/row/:id`             | Update row (`{ values, nulls? }` — `nulls` explicitly sets columns to NULL) |
 | PUT    | `/api/tables/:table/row/:id/generate`    | Generate UPDATE SQL (no execute) |
 | DELETE | `/api/tables/:table/row/:id`             | Delete row                       |
+| POST   | `/api/tables/:table/rows/bulk-impact`    | FK-impact preview: how many rows in other tables reference the selected rows |
+| POST   | `/api/tables/:table/rows/bulk-delete`    | Delete selected rows (`{ ids, confirmImpact }`; transactional) |
+| POST   | `/api/tables/:table/rows/bulk-export`    | Export only the selected rows as `csv`/`json` (`{ ids, format }`) |
+| POST   | `/api/tables/:table/rows/bulk-update`    | Apply staged inline edits (`{ updates: [{ id, values?, nulls? }] }`; transactional) |
 | POST   | `/api/tables`                            | Create table                     |
 | POST   | `/api/tables/generate`                   | Generate CREATE SQL (no execute) |
 | GET    | `/api/tables/:table/schema`              | Full schema (constraints, indexes, FK refs) |
@@ -248,15 +260,6 @@ $env:DB_DIR='./db'; npm start                 # PowerShell
 | DELETE | `/api/tables/:table`                     | Drop the table (safety-checked)  |
 | POST   | `/api/tables/:table/indexes`             | Create an index (`{ name?, columns[], unique? }`) |
 | DELETE | `/api/tables/:table/indexes/:index`      | Drop an index (auto indexes refused) |
-| GET    | `/api/views`                             | List views                       |
-| GET    | `/api/views/:name/rows`                  | Preview a view's rows            |
-| POST   | `/api/views/generate`                    | Generate CREATE VIEW SQL (no execute) |
-| POST   | `/api/views`                             | Create a view (`{ name, sql }`)  |
-| DELETE | `/api/views/:name`                       | Drop a view                      |
-| GET    | `/api/triggers`                          | List triggers                    |
-| POST   | `/api/triggers/generate`                 | Generate CREATE TRIGGER SQL (no execute) |
-| POST   | `/api/triggers`                          | Create a trigger (`{ name, table, timing, event, when?, body }`) |
-| DELETE | `/api/triggers/:name`                    | Drop a trigger                   |
 | POST   | `/api/query`                             | Run arbitrary SQL                |
 | POST   | `/api/query/export`                      | Run a SELECT and download as `csv`/`json` |
 | GET    | `/api/queries`                           | List saved queries               |
@@ -274,10 +277,26 @@ In multi-db mode, every route is scoped under the database, e.g.
 - **Insert forms pre-fill defaults.** On the "new row" form, columns that have
   a schema default are pre-filled (string/number/boolean literals and
   `CURRENT_TIMESTAMP`-style defaults) so you can see and adjust them.
-- **Row filters.** Each column's filter supports exact match (`=value`),
-  comparison (`>5`, `>=5`, `<5`, `<=5`, `!=value`), prefix (`pre*`) and
-  case-insensitive substring (plain text). Filters are carried in the URL and
-  survive sorting and pagination.
+- **Row filters.** The filter panel adapts to each column's type: foreign keys
+  become dropdowns (with a "not set / NULL" option), booleans become
+  any/true/false toggles, and dates and numbers become min/max range inputs.
+  Text columns keep the operator syntax: exact match (`=value`), comparison
+  (`>5`, `>=5`, `<5`, `<=5`, `!=value`), prefix (`pre*`) and case-insensitive
+  substring (plain text). Filters are carried in the URL (as legacy strings or
+  structured conditions) and survive sorting and pagination.
+- **Inline editing is staged, not instant.** Double-click a cell to edit it in
+  place; edits are buffered locally and highlighted in the grid rather than
+  written immediately. Press **Apply** to write every pending change to the
+  database in a single transaction (the page then reloads so related-row counts
+  stay accurate), or **Discard** to revert everything back to the saved values.
+  Clearing a text/date/number field stages a `NULL`.
+- **Bulk operations.** Checkboxes select rows on the current page; "select all"
+  checks every visible row. **Delete** first shows a warning listing each table
+  that references the selected rows and how many rows point at them (these may
+  be cascaded away or orphaned depending on the foreign-key action, and the
+  delete can fail if a constraint blocks it). **Export CSV / JSON** downloads
+  only the selected rows. Both delete and export are capped at 1000 rows per
+  batch.
 - **CSV import.** The first row must be a header whose names match existing
   columns (unknown or duplicate names are rejected). Empty cells are treated as
   "not set" so database defaults apply. The whole import runs in a single
@@ -311,8 +330,10 @@ npm test           # builds and runs the unit tests
 
 `npm test` compiles TypeScript to `dist/` and runs the `node:test` suite
 covering the SQL generator (INSERT / UPDATE / CREATE output, type mapping,
-quoting, rejection of unsupported types), the SQL classifier, and the database
-manager.
+quoting, rejection of unsupported types), the SQL classifier, CSV parsing and
+serialization, row filters (legacy and structured conditions), the database
+layer (pagination, transactions, bulk update/delete, read-only enforcement),
+and the database manager.
 
 ## Publishing to npm
 

package/dist/db/database.d.ts

@@ -1,5 +1,8 @@
 import type { Logger } from '../logger';
-import { type ColumnDef, type IndexDef, type TriggerDef } from '../sql/generator';
+import { type ColumnDef, type IndexDef } from '../sql/generator';
+import { type FilterValue } from '../util';
+/** Structured filter types are shared with the API layer. */
+export type { FilterCondition, FilterValue } from '../util';
 /** SQLite-compatible bind value accepted by better-sqlite3 statements. */
 export type SQLInputValue = null | number | bigint | string | Uint8Array;
 export interface Result<T = unknown> {
@@ -53,20 +56,8 @@ export interface IndexInfo {
     /** The `CREATE INDEX` statement from sqlite_master, when available. */
     sql?: string | null;
 }
-export interface ViewInfo {
-    name: string;
-    /** The `CREATE VIEW …` statement from sqlite_master. */
-    sql: string | null;
-}
-export interface TriggerInfo {
-    name: string;
-    /** The table (or view) the trigger fires on. */
-    table: string;
-    /** The `CREATE TRIGGER …` statement from sqlite_master. */
-    sql: string | null;
-}
 export interface RowFilters {
-    [column: string]: string;
+    [column: string]: FilterValue;
 }
 export interface ColumnDetail extends ColumnInfo {
     unique: boolean;
@@ -93,16 +84,19 @@ export interface SchemaInfo {
         to: string;
     }[];
 }
+export interface ReferencingTableInfo {
+    table: string;
+    /** FK columns in `table` that point at this table (`from` → `to`). */
+    refs: {
+        from: string;
+        to: string;
+    }[];
+    /** Rows in `table` whose FK column(s) actually reference this table. */
+    refCount: number;
+}
 export declare const INTERNAL_TABLES: {
     readonly savedQueries: "_saved_queries";
 };
-/**
- * Build a parameterized WHERE clause from per-column filters.
- * Supported syntax in a filter value:
- *   - `=value` exact match, `!=value` not-equal, `>value`, `>=value`, `<value`, `<=value`
- *   - `value*`  prefix match
- *   - anything else → case-insensitive substring (LIKE '%value%')
- */
 export declare function buildFilterClause(filters: RowFilters | undefined, availableCols: string[]): {
     where: string;
     params: SQLInputValue[];
@@ -137,6 +131,12 @@ export declare class SqliteDatabase {
     execResult(sql: string): Promise<Result<{
         changes?: number;
     }>>;
+    /**
+     * True when `sql` contains more than one statement. Detection is delegated to
+     * SQLite itself via `prepare()` (which refuses multi-statement strings), so
+     * comments, string literals and quoted identifiers are handled correctly.
+     */
+    hasMultipleStatements(sql: string): boolean;
     /** Run a write statement, reporting row changes when it is a single statement. */
     runWrite(sql: string): Promise<Result<{
         changes?: number;
@@ -166,10 +166,33 @@ export declare class SqliteDatabase {
         changes: number;
         lastInsertRowid: number | null;
     }>>;
+    /**
+     * Apply many row updates (each with its own SET fields + primary-key WHERE
+     * clause) inside a single transaction. Used by the bulk "apply changes"
+     * flow of inline grid editing. Rolls everything back if any row fails.
+     */
+    updateRows(table: string, rows: {
+        fields: WhereClause[];
+        where: WhereClause[];
+    }[]): Promise<Result<{
+        updated: number;
+    }>>;
     deleteRow(table: string, where: WhereClause[]): Promise<Result<{
         changes: number;
         lastInsertRowid: number | null;
     }>>;
+    /**
+     * Delete many rows (each identified by its primary-key WHERE clause) inside a
+     * single transaction. Used by bulk delete.
+     */
+    deleteRows(table: string, rows: WhereClause[][]): Promise<Result<{
+        deleted: number;
+    }>>;
+    /**
+     * Fetch the rows matching the given primary-key WHERE clauses in one query
+     * (`(a = ? AND b = ?) OR …`). Used by bulk export and FK-impact checks.
+     */
+    getRowsByPks(table: string, pks: WhereClause[][]): Promise<Result<Record<string, unknown>[]>>;
     getCreateStatement(table: string): Promise<Result<string | null>>;
     listSavedQueries(): Promise<Result<SavedQuery[]>>;
     saveQuery(name: string, sql: string): Promise<Result<{
@@ -185,6 +208,20 @@ export declare class SqliteDatabase {
      * foreign keys, and which other tables reference it.
      */
     getSchema(table: string): Promise<Result<SchemaInfo>>;
+    /**
+     * Other tables with foreign keys pointing at `table`, grouped by table, each
+     * with the FK column mapping and a count of rows that actually reference it.
+     */
+    getReferencingTables(table: string): Promise<Result<ReferencingTableInfo[]>>;
+    /**
+     * Rows in `table` whose `column` equals `value` — used to show which rows in
+     * a referencing table point at a specific row via a foreign key — with the
+     * total matching count.
+     */
+    getRowsByFk(table: string, column: string, value: unknown, limit?: number): Promise<Result<{
+        rows: Record<string, unknown>[];
+        total: number;
+    }>>;
     renameTable(oldName: string, newName: string): Promise<Result<{
         changes?: number;
     }>>;
@@ -206,21 +243,5 @@ export declare class SqliteDatabase {
     dropIndex(indexName: string): Promise<Result<{
         changes?: number;
     }>>;
-    listViews(): Promise<Result<ViewInfo[]>>;
-    /** Preview the first `limit` rows of a view (browse). */
-    getViewRows(viewName: string, limit?: number): Promise<Result<Record<string, unknown>[]>>;
-    createView(name: string, selectSql: string): Promise<Result<{
-        changes?: number;
-    }>>;
-    dropView(name: string): Promise<Result<{
-        changes?: number;
-    }>>;
-    listTriggers(): Promise<Result<TriggerInfo[]>>;
-    createTrigger(def: TriggerDef): Promise<Result<{
-        changes?: number;
-    }>>;
-    dropTrigger(name: string): Promise<Result<{
-        changes?: number;
-    }>>;
     private getTableInfoSync;
 }

package/dist/db/database.js

@@ -17,20 +17,87 @@ function escapeLike(s) {
 }
 /**
  * Build a parameterized WHERE clause from per-column filters.
- * Supported syntax in a filter value:
- *   - `=value` exact match, `!=value` not-equal, `>value`, `>=value`, `<value`, `<=value`
- *   - `value*`  prefix match
- *   - anything else → case-insensitive substring (LIKE '%value%')
+ *
+ * A filter value is either:
+ *   - the legacy string syntax: `=value` exact, `!=value`, `>value`, `>=value`,
+ *     `<value`, `<=value`, `value*` prefix, anything else → substring match; or
+ *   - a structured `FilterCondition` (or array of them) produced by the
+ *     type-aware filter form (FK dropdowns, boolean toggles, date/number ranges).
  */
+function pushFilterCondition(conds, params, quotedCol, c) {
+    const value = String(c.value ?? '');
+    switch (c.op) {
+        case 'eq':
+            conds.push(`${quotedCol} = ?`);
+            params.push(value);
+            break;
+        case 'neq':
+            conds.push(`${quotedCol} != ?`);
+            params.push(value);
+            break;
+        case 'gt':
+            conds.push(`${quotedCol} > ?`);
+            params.push(value);
+            break;
+        case 'gte':
+            conds.push(`${quotedCol} >= ?`);
+            params.push(value);
+            break;
+        case 'lt':
+            conds.push(`${quotedCol} < ?`);
+            params.push(value);
+            break;
+        case 'lte':
+            conds.push(`${quotedCol} <= ?`);
+            params.push(value);
+            break;
+        case 'like':
+            conds.push(`${quotedCol} LIKE ? ESCAPE '\\'`);
+            params.push('%' + escapeLike(value) + '%');
+            break;
+        case 'prefix':
+            conds.push(`${quotedCol} LIKE ? ESCAPE '\\'`);
+            params.push(escapeLike(value) + '%');
+            break;
+        case 'between':
+            conds.push(`${quotedCol} >= ?`);
+            params.push(value);
+            conds.push(`${quotedCol} <= ?`);
+            params.push(String(c.max ?? ''));
+            break;
+        case 'null':
+            conds.push(`${quotedCol} IS NULL`);
+            break;
+        case 'notnull':
+            conds.push(`${quotedCol} IS NOT NULL`);
+            break;
+        default:
+            break;
+    }
+}
 function buildFilterClause(filters, availableCols) {
     const conds = [];
     const params = [];
     const colSet = new Set(availableCols);
     for (const [col, raw] of Object.entries(filters ?? {})) {
-        const value = String(raw ?? '').trim();
-        if (value === '' || !colSet.has(col))
+        if (!colSet.has(col))
             continue;
         const q = (0, generator_1.quoteIdentifier)(col);
+        if (Array.isArray(raw)) {
+            for (const c of raw) {
+                if (c && typeof c === 'object')
+                    pushFilterCondition(conds, params, q, c);
+            }
+            continue;
+        }
+        if (raw && typeof raw === 'object') {
+            pushFilterCondition(conds, params, q, raw);
+            continue;
+        }
+        // Legacy string syntax.
+        const value = String(raw ?? '').trim();
+        if (value === '')
+            continue;
         if (value.startsWith('>=')) {
             conds.push(`${q} >= ?`);
             params.push(value.slice(2).trim());
@@ -153,6 +220,23 @@ class SqliteDatabase {
             return { changes: undefined };
         });
     }
+    /**
+     * True when `sql` contains more than one statement. Detection is delegated to
+     * SQLite itself via `prepare()` (which refuses multi-statement strings), so
+     * comments, string literals and quoted identifiers are handled correctly.
+     */
+    hasMultipleStatements(sql) {
+        const s = String(sql ?? '').trim();
+        if (!s)
+            return false;
+        try {
+            this.db.prepare(s);
+            return false;
+        }
+        catch (err) {
+            return /more than one statement/i.test((0, util_1.errorMessage)(err));
+        }
+    }
     /** Run a write statement, reporting row changes when it is a single statement. */
     async runWrite(sql) {
         if (this.isReadOnly)
@@ -294,11 +378,99 @@ class SqliteDatabase {
         const sql = `UPDATE ${(0, generator_1.quoteIdentifier)(table)} SET ${sets.join(', ')} WHERE ${conds.join(' AND ')}`;
         return this.run(sql, [...fields.map((f) => this.toBind(f.value)), ...where.map((w) => this.toBind(w.value))]);
     }
+    /**
+     * Apply many row updates (each with its own SET fields + primary-key WHERE
+     * clause) inside a single transaction. Used by the bulk "apply changes"
+     * flow of inline grid editing. Rolls everything back if any row fails.
+     */
+    async updateRows(table, rows) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(() => {
+            this.db.exec('BEGIN');
+            try {
+                let updated = 0;
+                for (const { fields, where } of rows) {
+                    if (!fields.length || !where.length)
+                        continue;
+                    const sets = fields.map((f) => `${(0, generator_1.quoteIdentifier)(f.column)} = ?`);
+                    const conds = where.map((w) => `${(0, generator_1.quoteIdentifier)(w.column)} = ?`);
+                    const sql = `UPDATE ${(0, generator_1.quoteIdentifier)(table)} SET ${sets.join(', ')} WHERE ${conds.join(' AND ')}`;
+                    const info = this.db.prepare(sql).run(...[...fields.map((f) => this.toBind(f.value)), ...where.map((w) => this.toBind(w.value))]);
+                    updated += Number(info.changes);
+                }
+                this.db.exec('COMMIT');
+                return { updated };
+            }
+            catch (err) {
+                try {
+                    this.db.exec('ROLLBACK');
+                }
+                catch {
+                    /* ignore */
+                }
+                throw err;
+            }
+        });
+    }
     async deleteRow(table, where) {
         const conds = where.map((w) => `${(0, generator_1.quoteIdentifier)(w.column)} = ?`);
         const sql = `DELETE FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${conds.join(' AND ')}`;
         return this.run(sql, where.map((w) => this.toBind(w.value)));
     }
+    /**
+     * Delete many rows (each identified by its primary-key WHERE clause) inside a
+     * single transaction. Used by bulk delete.
+     */
+    async deleteRows(table, rows) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(() => {
+            this.db.exec('BEGIN');
+            try {
+                let deleted = 0;
+                for (const where of rows) {
+                    if (!where.length)
+                        continue;
+                    const conds = where.map((w) => `${(0, generator_1.quoteIdentifier)(w.column)} = ?`);
+                    const sql = `DELETE FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${conds.join(' AND ')}`;
+                    const info = this.db.prepare(sql).run(...where.map((w) => this.toBind(w.value)));
+                    deleted += Number(info.changes);
+                }
+                this.db.exec('COMMIT');
+                return { deleted };
+            }
+            catch (err) {
+                try {
+                    this.db.exec('ROLLBACK');
+                }
+                catch {
+                    /* ignore */
+                }
+                throw err;
+            }
+        });
+    }
+    /**
+     * Fetch the rows matching the given primary-key WHERE clauses in one query
+     * (`(a = ? AND b = ?) OR …`). Used by bulk export and FK-impact checks.
+     */
+    async getRowsByPks(table, pks) {
+        return this.tryRun(() => {
+            const groups = [];
+            const params = [];
+            for (const where of pks) {
+                if (!where.length)
+                    continue;
+                groups.push(where.map((w) => `${(0, generator_1.quoteIdentifier)(w.column)} = ?`).join(' AND '));
+                params.push(...where.map((w) => this.toBind(w.value)));
+            }
+            if (!groups.length)
+                return [];
+            const sql = `SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${groups.map((g) => `(${g})`).join(' OR ')}`;
+            return this.db.prepare(sql).all(...params);
+        });
+    }
     async getCreateStatement(table) {
         return this.tryRun(() => {
             const row = this.db
@@ -426,6 +598,67 @@ class SqliteDatabase {
             };
         });
     }
+    /**
+     * Other tables with foreign keys pointing at `table`, grouped by table, each
+     * with the FK column mapping and a count of rows that actually reference it.
+     */
+    async getReferencingTables(table) {
+        return this.tryRun(() => {
+            const allTables = this.db
+                .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'")
+                .all().map((r) => r.name);
+            const byTable = new Map();
+            for (const t of allTables) {
+                if (t === table)
+                    continue;
+                try {
+                    const fks = this.db.prepare(`PRAGMA foreign_key_list(${(0, generator_1.quoteIdentifier)(t)})`).all();
+                    for (const fk of fks) {
+                        if (fk.table === table) {
+                            const arr = byTable.get(t) ?? [];
+                            arr.push({ from: fk.from, to: fk.to ?? '' });
+                            byTable.set(t, arr);
+                        }
+                    }
+                }
+                catch {
+                    /* ignore unreadable tables */
+                }
+            }
+            const result = [];
+            for (const [t, refs] of byTable) {
+                let refCount = 0;
+                try {
+                    const conds = refs.map((r) => `${(0, generator_1.quoteIdentifier)(r.from)} IS NOT NULL`);
+                    const row = this.db.prepare(`SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(t)} WHERE ${conds.join(' OR ')}`).get();
+                    refCount = Number(row.c);
+                }
+                catch {
+                    /* count is best-effort */
+                }
+                result.push({ table: t, refs, refCount });
+            }
+            result.sort((a, b) => a.table.localeCompare(b.table));
+            return result;
+        });
+    }
+    /**
+     * Rows in `table` whose `column` equals `value` — used to show which rows in
+     * a referencing table point at a specific row via a foreign key — with the
+     * total matching count.
+     */
+    async getRowsByFk(table, column, value, limit = 50) {
+        return this.tryRun(() => {
+            const n = Math.max(1, Math.min(500, Number(limit) || 50));
+            const countRow = this.db
+                .prepare(`SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${(0, generator_1.quoteIdentifier)(column)} = ?`)
+                .get(value);
+            const rows = this.db
+                .prepare(`SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${(0, generator_1.quoteIdentifier)(column)} = ? LIMIT ${n}`)
+                .all(value);
+            return { rows, total: Number(countRow.c) };
+        });
+    }
     async renameTable(oldName, newName) {
         return this.execResult((0, generator_1.generateRenameTable)(oldName, newName));
     }
@@ -447,42 +680,6 @@ class SqliteDatabase {
     async dropIndex(indexName) {
         return this.execResult((0, generator_1.generateDropIndex)(indexName));
     }
-    // ---- Views & triggers -------------------------------------------------
-    async listViews() {
-        return this.tryRun(() => {
-            const rows = this.db
-                .prepare("SELECT name, sql FROM sqlite_master WHERE type = 'view' AND name NOT LIKE 'sqlite_%' ORDER BY name")
-                .all();
-            return rows.map((r) => ({ name: r.name, sql: r.sql ?? null }));
-        });
-    }
-    /** Preview the first `limit` rows of a view (browse). */
-    async getViewRows(viewName, limit = 200) {
-        return this.tryRun(() => {
-            const n = Math.max(1, Math.min(1000, Number(limit) || 200));
-            return this.db.prepare(`SELECT * FROM ${(0, generator_1.quoteIdentifier)(viewName)} LIMIT ${n}`).all();
-        });
-    }
-    async createView(name, selectSql) {
-        return this.execResult((0, generator_1.generateCreateView)(name, selectSql));
-    }
-    async dropView(name) {
-        return this.execResult((0, generator_1.generateDropView)(name));
-    }
-    async listTriggers() {
-        return this.tryRun(() => {
-            const rows = this.db
-                .prepare('SELECT name, tbl_name AS "table", sql FROM sqlite_master WHERE type = \'trigger\' AND name NOT LIKE \'sqlite_%\' ORDER BY name')
-                .all();
-            return rows.map((r) => ({ name: r.name, table: r.table, sql: r.sql ?? null }));
-        });
-    }
-    async createTrigger(def) {
-        return this.execResult((0, generator_1.generateCreateTrigger)(def));
-    }
-    async dropTrigger(name) {
-        return this.execResult((0, generator_1.generateDropTrigger)(name));
-    }
     getTableInfoSync(table) {
         try {
             const cols = this.db.prepare(`PRAGMA table_info(${(0, generator_1.quoteIdentifier)(table)})`).all();