admindb 1.2.1 → 2.1.0

package/dist/db/database.js

@@ -1,153 +1,50 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqliteDatabase = exports.INTERNAL_TABLES = void 0;
-exports.buildFilterClause = buildFilterClause;
+exports.SqliteDatabase = void 0;
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const generator_1 = require("../sql/generator");
-const util_1 = require("../util");
-exports.INTERNAL_TABLES = {
-    savedQueries: '_saved_queries',
-};
-/** Escape LIKE wildcards so user filter text is matched literally. */
-function escapeLike(s) {
-    return String(s).replace(/[\\%_]/g, (m) => '\\' + m);
-}
+const common_1 = require("../utils/common");
+const types_1 = require("./types");
+const filters_1 = require("./filters");
+const introspection_1 = require("./introspection");
+const migrations_1 = require("./migrations");
+__exportStar(require("./types"), exports);
+__exportStar(require("./filters"), exports);
 /**
- * Build a parameterized WHERE clause from per-column filters.
- *
- * 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).
+ * Promise-style wrapper around the better-sqlite3 driver.
+ * Every call returns a consistent `{ success, data?, error? }` shape and
+ * performs one-time, idempotent schema initialization.
  */
-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 ?? {})) {
-        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());
-        }
-        else if (value.startsWith('<=')) {
-            conds.push(`${q} <= ?`);
-            params.push(value.slice(2).trim());
-        }
-        else if (value.startsWith('!=')) {
-            conds.push(`${q} != ?`);
-            params.push(value.slice(2).trim());
-        }
-        else if (value.startsWith('=')) {
-            conds.push(`${q} = ?`);
-            params.push(value.slice(1).trim());
-        }
-        else if (value.startsWith('>')) {
-            conds.push(`${q} > ?`);
-            params.push(value.slice(1).trim());
-        }
-        else if (value.startsWith('<')) {
-            conds.push(`${q} < ?`);
-            params.push(value.slice(1).trim());
-        }
-        else if (value.endsWith('*')) {
-            conds.push(`${q} LIKE ? ESCAPE '\\'`);
-            params.push(escapeLike(value.slice(0, -1)) + '%');
-        }
-        else {
-            conds.push(`${q} LIKE ? ESCAPE '\\'`);
-            params.push('%' + escapeLike(value) + '%');
-        }
-    }
-    return { where: conds.length ? ` WHERE ${conds.join(' AND ')}` : '', params };
-}
 class SqliteDatabase {
     db;
     logger;
     path;
-    /** True when this database was opened in read-only mode. */
     isReadOnly;
+    dialect = 'sqlite';
     constructor(dbPath, logger, options = {}) {
         this.path = dbPath;
         this.logger = logger;
         this.isReadOnly = !!options.readonly;
-        // Opening read-only also refuses to create the file when it does not exist.
         this.db = new better_sqlite3_1.default(dbPath, { readonly: this.isReadOnly });
         this.db.exec('PRAGMA foreign_keys = ON;');
         if (this.isReadOnly) {
-            // Belt-and-suspenders: even a direct write statement fails at the SQLite layer.
             this.db.exec('PRAGMA query_only = ON;');
         }
         else {
@@ -156,7 +53,6 @@ class SqliteDatabase {
         }
         this.logger.info(`Opened SQLite database at ${dbPath}${this.isReadOnly ? ' (read-only)' : ''}`);
     }
-    /** Standard error returned for every write attempt in read-only mode. */
     readonlyBlocked() {
         return { success: false, error: 'Database is open in read-only mode — write operations are disabled.' };
     }
@@ -165,12 +61,12 @@ class SqliteDatabase {
             this.db.close();
         }
         catch (err) {
-            this.logger.warn(`Failed to close database: ${(0, util_1.errorMessage)(err)}`);
+            this.logger.warn(`Failed to close database: ${(0, common_1.errorMessage)(err)}`);
         }
     }
     initSchema() {
         this.db.exec(`
-      CREATE TABLE IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(exports.INTERNAL_TABLES.savedQueries)} (
+      CREATE TABLE IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} (
         ${(0, generator_1.quoteIdentifier)('id')} INTEGER PRIMARY KEY AUTOINCREMENT,
         ${(0, generator_1.quoteIdentifier)('name')} TEXT NOT NULL UNIQUE,
         ${(0, generator_1.quoteIdentifier)('sql')} TEXT NOT NULL,
@@ -184,11 +80,31 @@ class SqliteDatabase {
             return { success: true, data };
         }
         catch (err) {
-            const msg = (0, util_1.errorMessage)(err);
+            const msg = (0, common_1.errorMessage)(err);
             this.logger.error(msg);
             return { success: false, error: msg };
         }
     }
+    /** Run an atomic transaction. Reverts on any error and enforces read-only mode. */
+    transaction(fn) {
+        if (this.isReadOnly)
+            return Promise.resolve(this.readonlyBlocked());
+        return this.tryRun(() => {
+            this.db.exec('BEGIN');
+            try {
+                const res = fn();
+                this.db.exec('COMMIT');
+                return res;
+            }
+            catch (err) {
+                try {
+                    this.db.exec('ROLLBACK');
+                }
+                catch { /* ignore */ }
+                throw err;
+            }
+        });
+    }
     toBind(value) {
         if (value === undefined)
             return null;
@@ -220,11 +136,6 @@ 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)
@@ -234,10 +145,9 @@ class SqliteDatabase {
             return false;
         }
         catch (err) {
-            return /more than one statement/i.test((0, util_1.errorMessage)(err));
+            return /more than one statement/i.test((0, common_1.errorMessage)(err));
         }
     }
-    /** Run a write statement, reporting row changes when it is a single statement. */
     async runWrite(sql) {
         if (this.isReadOnly)
             return this.readonlyBlocked();
@@ -247,89 +157,28 @@ class SqliteDatabase {
             const info = stmt.run();
             return { success: true, data: { changes: Number(info.changes) } };
         }
-        catch (err) {
-            // Possibly multiple statements — fall back to exec.
+        catch {
             try {
                 this.db.exec(String(sql));
                 return { success: true, data: { changes: undefined } };
             }
             catch (err2) {
-                const msg = (0, util_1.errorMessage)(err2);
+                const msg = (0, common_1.errorMessage)(err2);
                 this.logger.error(msg);
                 return { success: false, error: msg };
             }
         }
     }
     async listTables() {
-        return this.tryRun(() => {
-            const rows = this.db
-                .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
-                .all();
-            return rows.map((r) => ({ name: r.name }));
-        });
+        return this.tryRun(() => (0, introspection_1.listTablesSync)(this.db));
     }
     async getTableInfo(table) {
-        return this.tryRun(() => {
-            const cols = this.db.prepare(`PRAGMA table_info(${(0, generator_1.quoteIdentifier)(table)})`).all();
-            const fks = this.db.prepare(`PRAGMA foreign_key_list(${(0, generator_1.quoteIdentifier)(table)})`).all();
-            const primaryKey = cols
-                .filter((c) => c.pk > 0)
-                .sort((a, b) => a.pk - b.pk)
-                .map((c) => c.name);
-            // Indexes — the data generator needs them to detect UNIQUE columns and
-            // JSON-expression indexes (which throw "malformed JSON" at insert time
-            // if the column is filled with non-JSON text).
-            const indexRows = this.db
-                .prepare(`PRAGMA index_list(${(0, generator_1.quoteIdentifier)(table)})`)
-                .all();
-            const indexes = indexRows.map((ix) => {
-                const ixCols = this.db
-                    .prepare(`PRAGMA index_info(${(0, generator_1.quoteIdentifier)(ix.name)})`)
-                    .all().map((c) => c.name);
-                const sqlRow = this.db
-                    .prepare("SELECT sql FROM sqlite_master WHERE type = 'index' AND name = ?")
-                    .get(ix.name);
-                return {
-                    name: ix.name,
-                    unique: !!ix.unique,
-                    partial: ix.partial,
-                    origin: ix.origin,
-                    columns: ixCols,
-                    sql: sqlRow?.sql ?? null,
-                };
-            });
-            const ddlRow = this.db
-                .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?")
-                .get(table);
-            return {
-                table,
-                columns: cols.map((c) => ({
-                    cid: c.cid,
-                    name: c.name,
-                    type: c.type,
-                    notnull: c.notnull,
-                    dflt_value: c.dflt_value,
-                    pk: c.pk,
-                })),
-                foreignKeys: fks.map((f) => ({
-                    id: f.id,
-                    seq: f.seq,
-                    table: f.table,
-                    from: f.from,
-                    to: f.to,
-                    on_update: f.on_update,
-                    on_delete: f.on_delete,
-                })),
-                primaryKey,
-                indexes,
-                sql: ddlRow?.sql ?? null,
-            };
-        });
+        return this.tryRun(() => (0, introspection_1.getTableInfoSync)(this.db, table));
     }
     async getRowCount(table, filters) {
         return this.tryRun(() => {
             const info = this.getTableInfoSync(table);
-            const { where, params } = buildFilterClause(filters, info?.columns.map((c) => c.name) ?? []);
+            const { where, params } = (0, filters_1.buildFilterClause)(filters, info?.columns.map((c) => c.name) ?? []);
             const row = this.db
                 .prepare(`SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(table)}${where}`)
                 .get(...params);
@@ -345,8 +194,8 @@ class SqliteDatabase {
             const limit = opts.limit && opts.limit > 0 ? opts.limit : 200;
             const page = opts.page && opts.page > 0 ? opts.page : 1;
             const offset = (page - 1) * limit;
-            const { where, params } = buildFilterClause(opts.filters, cols.map((c) => c.name));
-            let sql = `SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)}${where}`;
+            const { where, params } = (0, filters_1.buildFilterClause)(opts.filters, cols.map((c) => c.name));
+            let sql = `SELECT rowid AS _rowid_, * FROM ${(0, generator_1.quoteIdentifier)(table)}${where}`;
             if (orderCol)
                 sql += ` ORDER BY ${(0, generator_1.quoteIdentifier)(orderCol)} ${orderDir}`;
             sql += ` LIMIT ${limit} OFFSET ${offset}`;
@@ -354,12 +203,12 @@ class SqliteDatabase {
         });
     }
     async getAllRows(table) {
-        return this.tryRun(() => this.db.prepare(`SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)}`).all());
+        return this.tryRun(() => this.db.prepare(`SELECT rowid AS _rowid_, * FROM ${(0, generator_1.quoteIdentifier)(table)}`).all());
     }
     async getRow(table, where) {
         return this.tryRun(() => {
             const conds = where.map((w) => `${(0, generator_1.quoteIdentifier)(w.column)} = ?`);
-            const sql = `SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${conds.join(' AND ')} LIMIT 1`;
+            const sql = `SELECT rowid AS _rowid_, * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${conds.join(' AND ')} LIMIT 1`;
             const row = this.db.prepare(sql).get(...where.map((w) => this.toBind(w.value)));
             return row ? row : null;
         });
@@ -369,34 +218,19 @@ class SqliteDatabase {
         const sql = `INSERT INTO ${(0, generator_1.quoteIdentifier)(table)} (${cols.join(', ')}) VALUES (${fields.map(() => '?').join(', ')})`;
         return this.run(sql, fields.map((f) => this.toBind(f.value)));
     }
-    /** Insert many rows (used by CSV import) inside a single transaction. */
+    /** Insert many rows inside a single atomic transaction. */
     async insertRows(table, rows) {
-        if (this.isReadOnly)
-            return this.readonlyBlocked();
-        return this.tryRun(() => {
-            this.db.exec('BEGIN');
-            try {
-                let inserted = 0;
-                for (const fields of rows) {
-                    if (!fields.length)
-                        continue;
-                    const cols = fields.map((f) => (0, generator_1.quoteIdentifier)(f.column));
-                    const sql = `INSERT INTO ${(0, generator_1.quoteIdentifier)(table)} (${cols.join(', ')}) VALUES (${fields.map(() => '?').join(', ')})`;
-                    this.db.prepare(sql).run(...fields.map((f) => this.toBind(f.value)));
-                    inserted += 1;
-                }
-                this.db.exec('COMMIT');
-                return { inserted, skipped: rows.length - inserted };
-            }
-            catch (err) {
-                try {
-                    this.db.exec('ROLLBACK');
-                }
-                catch {
-                    /* ignore */
-                }
-                throw err;
+        return this.transaction(() => {
+            let inserted = 0;
+            for (const fields of rows) {
+                if (!fields.length)
+                    continue;
+                const cols = fields.map((f) => (0, generator_1.quoteIdentifier)(f.column));
+                const sql = `INSERT INTO ${(0, generator_1.quoteIdentifier)(table)} (${cols.join(', ')}) VALUES (${fields.map(() => '?').join(', ')})`;
+                this.db.prepare(sql).run(...fields.map((f) => this.toBind(f.value)));
+                inserted += 1;
             }
+            return { inserted, skipped: rows.length - inserted };
         });
     }
     async updateRow(table, fields, where) {
@@ -405,39 +239,20 @@ 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.
-     */
+    /** Apply many row updates inside a single atomic transaction. */
     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;
+        return this.transaction(() => {
+            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);
             }
+            return { updated };
         });
     }
     async deleteRow(table, where) {
@@ -445,43 +260,21 @@ class SqliteDatabase {
         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.
-     */
+    /** Delete many rows inside a single atomic transaction. */
     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;
+        return this.transaction(() => {
+            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);
             }
+            return { deleted };
         });
     }
-    /**
-     * 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 = [];
@@ -494,7 +287,7 @@ class SqliteDatabase {
             }
             if (!groups.length)
                 return [];
-            const sql = `SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${groups.map((g) => `(${g})`).join(' OR ')}`;
+            const sql = `SELECT rowid AS _rowid_, * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${groups.map((g) => `(${g})`).join(' OR ')}`;
             return this.db.prepare(sql).all(...params);
         });
     }
@@ -507,173 +300,20 @@ class SqliteDatabase {
         });
     }
     async listSavedQueries() {
-        return this.all(`SELECT id, name, sql, created_at FROM ${(0, generator_1.quoteIdentifier)(exports.INTERNAL_TABLES.savedQueries)} ORDER BY name COLLATE NOCASE`);
+        return this.all(`SELECT id, name, sql, created_at FROM ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} ORDER BY name COLLATE NOCASE`);
     }
     async saveQuery(name, sql) {
-        return this.run(`INSERT INTO ${(0, generator_1.quoteIdentifier)(exports.INTERNAL_TABLES.savedQueries)} (name, sql) VALUES (?, ?)`, [name, sql]);
+        return this.run(`INSERT INTO ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} (name, sql) VALUES (?, ?)`, [name, sql]);
     }
     async deleteSavedQuery(id) {
-        return this.run(`DELETE FROM ${(0, generator_1.quoteIdentifier)(exports.INTERNAL_TABLES.savedQueries)} WHERE id = ?`, [Number(id)]);
+        return this.run(`DELETE FROM ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} WHERE id = ?`, [Number(id)]);
     }
-    // ---- Schema introspection & ALTER -------------------------------------
-    /**
-     * Detailed schema for a table: columns with constraint info, indexes,
-     * foreign keys, and which other tables reference it.
-     */
     async getSchema(table) {
-        return this.tryRun(() => {
-            const info = this.getTableInfoSync(table);
-            if (!info || info.columns.length === 0)
-                throw new Error(`Table "${table}" does not exist.`);
-            // Foreign keys declared on this table (child FKs).
-            const fkRows = this.db
-                .prepare(`PRAGMA foreign_key_list(${(0, generator_1.quoteIdentifier)(table)})`)
-                .all();
-            const foreignKeys = fkRows.map((f) => ({
-                id: f.id,
-                seq: f.seq,
-                table: f.table,
-                from: f.from,
-                to: f.to,
-                on_update: f.on_update,
-                on_delete: f.on_delete,
-            }));
-            const indexRows = this.db
-                .prepare(`PRAGMA index_list(${(0, generator_1.quoteIdentifier)(table)})`)
-                .all();
-            const indexes = indexRows.map((ix) => {
-                const cols = this.db
-                    .prepare(`PRAGMA index_info(${(0, generator_1.quoteIdentifier)(ix.name)})`)
-                    .all().map((c) => c.name);
-                const sqlRow = this.db
-                    .prepare("SELECT sql FROM sqlite_master WHERE type = 'index' AND name = ?")
-                    .get(ix.name);
-                return { name: ix.name, unique: !!ix.unique, partial: ix.partial, origin: ix.origin, columns: cols, sql: sqlRow?.sql ?? null };
-            });
-            const uniqueCols = new Set();
-            const indexedCols = new Set();
-            const originByName = new Map(indexRows.map((ix) => [ix.name, ix.origin]));
-            for (const ix of indexes) {
-                if (ix.unique)
-                    ix.columns.forEach((c) => uniqueCols.add(c));
-                // 'c' = explicit CREATE INDEX; these block DROP COLUMN.
-                if (originByName.get(ix.name) === 'c')
-                    ix.columns.forEach((c) => indexedCols.add(c));
-            }
-            // Foreign keys in OTHER tables that point at this table.
-            const refs = [];
-            const allTables = this.db
-                .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'")
-                .all().map((r) => r.name);
-            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)
-                            refs.push({ table: t, from: fk.from, to: fk.to ?? '' });
-                    }
-                }
-                catch {
-                    /* ignore unreadable tables */
-                }
-            }
-            const refsByTo = new Map();
-            for (const r of refs) {
-                const arr = refsByTo.get(r.to) ?? [];
-                arr.push({ table: r.table, from: r.from });
-                refsByTo.set(r.to, arr);
-            }
-            const fkByFrom = new Map();
-            for (const fk of foreignKeys)
-                fkByFrom.set(fk.from, fk);
-            const columns = info.columns.map((c) => {
-                const unique = c.pk > 0 || uniqueCols.has(c.name);
-                const indexed = indexedCols.has(c.name);
-                const referencedBy = refsByTo.get(c.name) ?? [];
-                const fk = fkByFrom.get(c.name) ?? null;
-                const dropBlockers = [];
-                if (c.pk > 0)
-                    dropBlockers.push('Is part of the primary key');
-                if (unique && c.pk === 0)
-                    dropBlockers.push('Has a UNIQUE constraint');
-                if (indexed)
-                    dropBlockers.push('Is used by an index');
-                if (referencedBy.length)
-                    dropBlockers.push(`Referenced by a foreign key in "${referencedBy[0].table}"`);
-                if (fk)
-                    dropBlockers.push('Is part of a foreign key');
-                return {
-                    ...c,
-                    unique,
-                    indexed,
-                    referencedBy,
-                    fk,
-                    canDrop: dropBlockers.length === 0,
-                    dropBlockers,
-                };
-            });
-            return {
-                table,
-                columns,
-                foreignKeys,
-                indexes,
-                references: refs,
-            };
-        });
+        return this.tryRun(() => (0, introspection_1.getSchemaSync)(this.db, table));
     }
-    /**
-     * 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;
-        });
+        return this.tryRun(() => (0, introspection_1.getReferencingTablesSync)(this.db, table));
     }
-    /**
-     * 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));
@@ -690,10 +330,117 @@ class SqliteDatabase {
         return this.execResult((0, generator_1.generateRenameTable)(oldName, newName));
     }
     async addColumn(table, col) {
-        return this.execResult((0, generator_1.generateAddColumn)(table, col));
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(() => {
+            if (col.primaryKey) {
+                return (0, migrations_1.modifyTableStructureSync)(this.db, table, (existingCols) => [...existingCols, col]);
+            }
+            try {
+                const colCopy = { ...col, unique: false };
+                const sql = (0, generator_1.generateAddColumn)(table, colCopy);
+                this.db.exec(sql);
+                if (col.unique) {
+                    const idxName = `idx_${table}_${col.name}_unique`;
+                    this.db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(idxName)} ON ${(0, generator_1.quoteIdentifier)(table)} (${(0, generator_1.quoteIdentifier)(col.name)});`);
+                }
+                return { changes: 1 };
+            }
+            catch {
+                return (0, migrations_1.modifyTableStructureSync)(this.db, table, (existingCols) => [...existingCols, col]);
+            }
+        });
+    }
+    async modifyColumn(table, oldColName, newColDef) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(() => {
+            const newName = String(newColDef.name || oldColName).trim();
+            const rawCols = this.db.prepare(`PRAGMA table_info(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            const existing = rawCols.find((c) => c.name === oldColName);
+            if (!existing)
+                throw new Error(`Column "${oldColName}" does not exist in table "${table}".`);
+            const fks = this.db.prepare(`PRAGMA foreign_key_list(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            const existingFk = fks.find((f) => f.from === oldColName);
+            const indexRows = this.db.prepare(`PRAGMA index_list(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            let existingIsUnique = false;
+            for (const ix of indexRows) {
+                if (ix.unique) {
+                    const ixCols = this.db.prepare(`PRAGMA index_info(${(0, generator_1.quoteIdentifier)(ix.name)})`).all().map((c) => c.name);
+                    if (ixCols.length === 1 && ixCols[0] === oldColName) {
+                        existingIsUnique = true;
+                        break;
+                    }
+                }
+            }
+            const typeMatches = !newColDef.type || newColDef.type.toUpperCase() === existing.type.toUpperCase();
+            const pkMatches = newColDef.primaryKey === undefined || newColDef.primaryKey === (existing.pk > 0);
+            const notNullMatches = newColDef.notNull === undefined || newColDef.notNull === (!!existing.notnull);
+            const uniqueMatches = newColDef.unique === undefined || newColDef.unique === existingIsUnique;
+            const defaultMatches = newColDef.defaultValue === undefined || String(newColDef.defaultValue ?? '').trim() === String(existing.dflt_value ?? '').trim();
+            const fkMatches = newColDef.foreignKey === undefined || ((!newColDef.foreignKey && !existingFk) ||
+                (newColDef.foreignKey && existingFk && newColDef.foreignKey.table === existingFk.table && newColDef.foreignKey.column === existingFk.to));
+            // Fast path: if ONLY the column name changed, use native RENAME COLUMN.
+            if (oldColName !== newName && typeMatches && pkMatches && notNullMatches && uniqueMatches && defaultMatches && fkMatches) {
+                this.db.exec((0, generator_1.generateRenameColumn)(table, oldColName, newName));
+                const existingIdxNames = new Set(indexRows.map((i) => i.name));
+                for (const suffix of ['', '_unique']) {
+                    const defaultOldIdx = `idx_${table}_${oldColName}${suffix}`;
+                    if (existingIdxNames.has(defaultOldIdx)) {
+                        const newIdxName = `idx_${table}_${newName}${suffix}`;
+                        const uniqueKeyword = suffix === '_unique' ? 'UNIQUE ' : '';
+                        try {
+                            this.db.exec(`DROP INDEX ${(0, generator_1.quoteIdentifier)(defaultOldIdx)};`);
+                            this.db.exec(`CREATE ${uniqueKeyword}INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(newIdxName)} ON ${(0, generator_1.quoteIdentifier)(table)} (${(0, generator_1.quoteIdentifier)(newName)});`);
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
+                return { changes: 1 };
+            }
+            if (oldColName === newName && typeMatches && pkMatches && notNullMatches && uniqueMatches && defaultMatches && fkMatches) {
+                return { changes: 0 };
+            }
+            return (0, migrations_1.modifyTableStructureSync)(this.db, table, (cols) => {
+                const idx = cols.findIndex((c) => c.name === oldColName);
+                if (idx === -1)
+                    throw new Error(`Column "${oldColName}" does not exist in table "${table}".`);
+                const updated = [...cols];
+                updated[idx] = {
+                    ...updated[idx],
+                    name: newName,
+                    type: newColDef.type || updated[idx].type,
+                    primaryKey: newColDef.primaryKey !== undefined ? newColDef.primaryKey : updated[idx].primaryKey,
+                    notNull: newColDef.notNull !== undefined ? newColDef.notNull : updated[idx].notNull,
+                    unique: newColDef.unique !== undefined ? newColDef.unique : updated[idx].unique,
+                    defaultValue: newColDef.defaultValue !== undefined ? newColDef.defaultValue : updated[idx].defaultValue,
+                    foreignKey: newColDef.foreignKey !== undefined ? newColDef.foreignKey : updated[idx].foreignKey,
+                };
+                return updated;
+            }, oldColName, newName);
+        });
     }
     async renameColumn(table, oldName, newName) {
-        return this.execResult((0, generator_1.generateRenameColumn)(table, oldName, newName));
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(() => {
+            this.db.exec((0, generator_1.generateRenameColumn)(table, oldName, newName));
+            const indexRows = this.db.prepare(`PRAGMA index_list(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            const existingIdxNames = new Set(indexRows.map((i) => i.name));
+            for (const suffix of ['', '_unique']) {
+                const defaultOldIdx = `idx_${table}_${oldName}${suffix}`;
+                if (existingIdxNames.has(defaultOldIdx)) {
+                    const newIdxName = `idx_${table}_${newName}${suffix}`;
+                    const uniqueKeyword = suffix === '_unique' ? 'UNIQUE ' : '';
+                    try {
+                        this.db.exec(`DROP INDEX ${(0, generator_1.quoteIdentifier)(defaultOldIdx)};`);
+                        this.db.exec(`CREATE ${uniqueKeyword}INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(newIdxName)} ON ${(0, generator_1.quoteIdentifier)(table)} (${(0, generator_1.quoteIdentifier)(newName)});`);
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+            return { changes: 1 };
+        });
     }
     async dropColumn(table, column) {
         return this.execResult((0, generator_1.generateDropColumn)(table, column));