admindb 1.2.1 → 2.1.0

package/dist/db/postgres.js

@@ -0,0 +1,745 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresDatabase = void 0;
+const pg_1 = require("pg");
+const generator_1 = require("../sql/generator");
+const common_1 = require("../utils/common");
+const types_1 = require("./types");
+const filters_1 = require("./filters");
+class PostgresDatabase {
+    pool;
+    logger;
+    path;
+    isReadOnly;
+    dialect = 'postgres';
+    schema;
+    constructor(connection, logger, options = {}) {
+        this.logger = logger;
+        const opts = typeof connection === 'string'
+            ? { connectionString: connection, ...options }
+            : { ...connection, ...options };
+        this.isReadOnly = Boolean(opts.readonly);
+        this.schema = opts.schema || 'public';
+        let sslConfig = opts.ssl;
+        if (opts.connectionString) {
+            try {
+                const u = new URL(opts.connectionString);
+                const sslMode = (u.searchParams.get('sslmode') || u.searchParams.get('ssl') || '').toLowerCase();
+                const host = u.hostname.toLowerCase();
+                const isLocal = host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0';
+                if (sslMode === 'disable') {
+                    sslConfig = false;
+                }
+                else if (sslConfig === undefined) {
+                    // Auto-enable SSL for remote/cloud hosts (e.g. Neon, Supabase, Render, Railway, AWS RDS, etc.)
+                    // or whenever sslmode is specified or not explicitly local
+                    if (sslMode === 'require' || sslMode === 'prefer' || sslMode === 'no-verify' || !isLocal) {
+                        sslConfig = { rejectUnauthorized: false };
+                    }
+                }
+            }
+            catch {
+                /* ignore URL parse error */
+            }
+        }
+        else if (opts.host && sslConfig === undefined) {
+            const host = opts.host.toLowerCase();
+            const isLocal = host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0';
+            if (!isLocal) {
+                sslConfig = { rejectUnauthorized: false };
+            }
+        }
+        const poolConfig = {
+            connectionString: opts.connectionString,
+            host: opts.host,
+            port: opts.port,
+            database: opts.database,
+            user: opts.user,
+            password: opts.password,
+            ssl: sslConfig,
+            max: opts.max ?? 10,
+            connectionTimeoutMillis: 10000,
+            idleTimeoutMillis: 30000,
+            keepAlive: true,
+        };
+        this.path = opts.connectionString
+            ? this.sanitizeConnectionString(opts.connectionString)
+            : `${opts.user || 'postgres'}@${opts.host || 'localhost'}:${opts.port || 5432}/${opts.database || 'postgres'}`;
+        this.pool = new pg_1.Pool(poolConfig);
+        this.pool.on('error', (err) => {
+            this.logger.error(`Unexpected PostgreSQL client error: ${(0, common_1.errorMessage)(err)}`);
+        });
+        if (!this.isReadOnly) {
+            this.initSchema().catch((err) => {
+                this.logger.warn(`Failed to initialize Postgres schema: ${(0, common_1.errorMessage)(err)}`);
+            });
+        }
+        this.logger.info(`Initialized PostgreSQL pool for ${this.path}${this.isReadOnly ? ' (read-only)' : ''}`);
+    }
+    sanitizeConnectionString(conn) {
+        try {
+            const url = new URL(conn);
+            if (url.password)
+                url.password = '****';
+            return url.toString();
+        }
+        catch {
+            return conn.replace(/:([^@]+)@/, ':****@');
+        }
+    }
+    readonlyBlocked() {
+        return { success: false, error: 'Database is open in read-only mode — write operations are disabled.' };
+    }
+    async close() {
+        try {
+            await this.pool.end();
+        }
+        catch (err) {
+            this.logger.warn(`Failed to close PostgreSQL pool: ${(0, common_1.errorMessage)(err)}`);
+        }
+    }
+    async tryRun(fn) {
+        try {
+            const data = await fn();
+            return { success: true, data };
+        }
+        catch (err) {
+            const msg = (0, common_1.errorMessage)(err);
+            this.logger.error(msg);
+            return { success: false, error: msg };
+        }
+    }
+    /** Run a callback inside an atomic transaction on a dedicated client. */
+    async transaction(fn) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        const client = await this.pool.connect();
+        try {
+            await client.query('BEGIN');
+            const res = await fn(client);
+            await client.query('COMMIT');
+            return { success: true, data: res };
+        }
+        catch (err) {
+            try {
+                await client.query('ROLLBACK');
+            }
+            catch {
+                /* ignore */
+            }
+            const msg = (0, common_1.errorMessage)(err);
+            this.logger.error(msg);
+            return { success: false, error: msg };
+        }
+        finally {
+            client.release();
+        }
+    }
+    async initSchema() {
+        const sql = `
+      CREATE TABLE IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        sql TEXT NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      );
+    `;
+        await this.pool.query(sql);
+    }
+    hasMultipleStatements(sql) {
+        const s = String(sql ?? '').trim();
+        if (!s)
+            return false;
+        let count = 0;
+        let inString = false;
+        for (let i = 0; i < s.length; i++) {
+            const ch = s[i];
+            if (ch === "'") {
+                if (inString && s[i + 1] === "'") {
+                    i++;
+                    continue;
+                }
+                inString = !inString;
+            }
+            else if (ch === ';' && !inString) {
+                // Only count if there are non-whitespace characters following
+                const rest = s.slice(i + 1).trim();
+                if (rest.length > 0)
+                    count++;
+            }
+        }
+        return count > 0;
+    }
+    async all(sql, params = []) {
+        return this.tryRun(async () => {
+            const pgSql = (0, filters_1.convertPlaceholdersToPostgres)(sql);
+            const res = await this.pool.query(pgSql, params);
+            return res.rows;
+        });
+    }
+    async run(sql, params = []) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            const pgSql = (0, filters_1.convertPlaceholdersToPostgres)(sql);
+            const res = await this.pool.query(pgSql, params);
+            return {
+                changes: res.rowCount ?? 0,
+                lastInsertRowid: null,
+            };
+        });
+    }
+    async execResult(sql) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            const res = await this.pool.query(sql);
+            const changes = Array.isArray(res)
+                ? res.reduce((acc, r) => acc + (r.rowCount ?? 0), 0)
+                : res.rowCount ?? undefined;
+            return { changes };
+        });
+    }
+    async runWrite(sql) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            const res = await this.pool.query(sql);
+            const changes = Array.isArray(res)
+                ? res.reduce((acc, r) => acc + (r.rowCount ?? 0), 0)
+                : res.rowCount ?? undefined;
+            return { changes };
+        });
+    }
+    async listTables() {
+        return this.tryRun(async () => {
+            const res = await this.pool.query(`SELECT table_name AS name
+         FROM information_schema.tables
+         WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+         ORDER BY table_name;`, [this.schema]);
+            return res.rows.map((r) => ({ name: r.name }));
+        });
+    }
+    async getTableInfo(table) {
+        return this.tryRun(async () => {
+            // Execute all 4 metadata queries concurrently in parallel
+            const [colRes, pkRes, fkRes, idxRes] = await Promise.all([
+                // 1. Columns
+                this.pool.query(`SELECT
+             ordinal_position AS cid,
+             column_name AS name,
+             data_type AS type,
+             udt_name,
+             CASE WHEN is_nullable = 'NO' THEN 1 ELSE 0 END AS notnull,
+             column_default AS dflt_value
+           FROM information_schema.columns
+           WHERE table_schema = $1 AND table_name = $2
+           ORDER BY ordinal_position;`, [this.schema, table]),
+                // 2. Primary Keys
+                this.pool.query(`SELECT kcu.column_name
+           FROM information_schema.table_constraints tc
+           JOIN information_schema.key_column_usage kcu
+             ON tc.constraint_name = kcu.constraint_name
+             AND tc.table_schema = kcu.table_schema
+           WHERE tc.constraint_type = 'PRIMARY KEY'
+             AND tc.table_schema = $1
+             AND tc.table_name = $2
+           ORDER BY kcu.ordinal_position;`, [this.schema, table]),
+                // 3. Foreign Keys
+                this.pool.query(`SELECT
+             row_number() OVER () AS id,
+             kcu.position_in_unique_constraint AS seq,
+             ccu.table_name AS table,
+             kcu.column_name AS "from",
+             ccu.column_name AS "to",
+             rc.update_rule AS on_update,
+             rc.delete_rule AS on_delete
+           FROM information_schema.table_constraints AS tc
+           JOIN information_schema.key_column_usage AS kcu
+             ON tc.constraint_name = kcu.constraint_name
+             AND tc.table_schema = kcu.table_schema
+           JOIN information_schema.constraint_column_usage AS ccu
+             ON ccu.constraint_name = tc.constraint_name
+             AND ccu.table_schema = tc.table_schema
+           JOIN information_schema.referential_constraints AS rc
+             ON rc.constraint_name = tc.constraint_name
+             AND rc.constraint_schema = tc.table_schema
+           WHERE tc.constraint_type = 'FOREIGN KEY'
+             AND tc.table_schema = $1
+             AND tc.table_name = $2;`, [this.schema, table]),
+                // 4. Indexes
+                this.pool.query(`SELECT
+             i.relname AS name,
+             ix.indisunique AS unique,
+             pg_get_indexdef(ix.indexrelid) AS sql,
+             ARRAY(
+               SELECT pg_get_indexdef(ix.indexrelid, k + 1, true)
+               FROM generate_subscripts(ix.indkey, 1) as k
+               ORDER BY k
+             ) AS columns
+           FROM pg_index ix
+           JOIN pg_class t ON t.oid = ix.indrelid
+           JOIN pg_class i ON i.oid = ix.indexrelid
+           JOIN pg_namespace n ON n.oid = t.relnamespace
+           WHERE n.nspname = $1 AND t.relname = $2;`, [this.schema, table]),
+            ]);
+            const primaryKey = pkRes.rows.map((r) => r.column_name);
+            const columns = colRes.rows.map((c) => {
+                const isPk = primaryKey.includes(c.name);
+                const displayType = c.type === 'USER-DEFINED' ? c.udt_name : c.type;
+                return {
+                    cid: c.cid,
+                    name: c.name,
+                    type: displayType.toUpperCase(),
+                    notnull: c.notnull,
+                    dflt_value: c.dflt_value,
+                    pk: isPk ? primaryKey.indexOf(c.name) + 1 : 0,
+                };
+            });
+            const indexes = idxRes.rows.map((ix) => ({
+                name: ix.name,
+                unique: Boolean(ix.unique),
+                partial: 0,
+                origin: 'c',
+                columns: Array.isArray(ix.columns) ? ix.columns : [],
+                sql: ix.sql,
+            }));
+            // Approximate DDL for display
+            const colDefs = columns.map((c) => {
+                let def = `  ${(0, generator_1.quoteIdentifier)(c.name)} ${c.type}`;
+                if (c.notnull)
+                    def += ' NOT NULL';
+                if (c.dflt_value)
+                    def += ` DEFAULT ${c.dflt_value}`;
+                return def;
+            });
+            if (primaryKey.length) {
+                colDefs.push(`  PRIMARY KEY (${primaryKey.map(generator_1.quoteIdentifier).join(', ')})`);
+            }
+            const synthesizedSql = `CREATE TABLE ${(0, generator_1.quoteIdentifier)(table)} (\n${colDefs.join(',\n')}\n);`;
+            return {
+                table,
+                columns,
+                foreignKeys: fkRes.rows.map((f) => ({
+                    id: Number(f.id),
+                    seq: Number(f.seq ?? 1),
+                    table: f.table,
+                    from: f.from,
+                    to: f.to,
+                    on_update: f.on_update,
+                    on_delete: f.on_delete,
+                })),
+                primaryKey,
+                indexes,
+                sql: synthesizedSql,
+            };
+        });
+    }
+    async getRowCount(table, filters) {
+        return this.tryRun(async () => {
+            let pgWhere = '';
+            let params = [];
+            if (filters && Object.keys(filters).length > 0) {
+                const { where, params: p } = (0, filters_1.buildFilterClause)(filters, Object.keys(filters));
+                pgWhere = (0, filters_1.convertPlaceholdersToPostgres)(where);
+                params = p;
+            }
+            const sql = `SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(table)}${pgWhere}`;
+            const res = await this.pool.query(sql, params);
+            return Number(res.rows[0]?.c ?? 0);
+        });
+    }
+    async getRows(table, opts = {}) {
+        return this.tryRun(async () => {
+            const orderCol = opts.orderBy;
+            const orderDir = opts.orderDir === 'desc' ? 'DESC' : 'ASC';
+            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;
+            let pgWhere = '';
+            let filterParams = [];
+            if (opts.filters && Object.keys(opts.filters).length > 0) {
+                const { where, params } = (0, filters_1.buildFilterClause)(opts.filters, Object.keys(opts.filters));
+                pgWhere = (0, filters_1.convertPlaceholdersToPostgres)(where);
+                filterParams = params;
+            }
+            const nextParamIdx = filterParams.length + 1;
+            let sql = `SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)}${pgWhere}`;
+            if (orderCol) {
+                sql += ` ORDER BY ${(0, generator_1.quoteIdentifier)(orderCol)} ${orderDir}`;
+            }
+            sql += ` LIMIT $${nextParamIdx} OFFSET $${nextParamIdx + 1}`;
+            const allParams = [...filterParams, limit, offset];
+            const res = await this.pool.query(sql, allParams);
+            return res.rows;
+        });
+    }
+    async getAllRows(table) {
+        return this.tryRun(async () => {
+            const res = await this.pool.query(`SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)}`);
+            return res.rows;
+        });
+    }
+    async getRow(table, where) {
+        return this.tryRun(async () => {
+            const conds = where.map((w, idx) => `${(0, generator_1.quoteIdentifier)(w.column)} = $${idx + 1}`);
+            const sql = `SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${conds.join(' AND ')} LIMIT 1`;
+            const res = await this.pool.query(sql, where.map((w) => w.value));
+            return res.rows[0] ?? null;
+        });
+    }
+    async insertRow(table, fields) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            const cols = fields.map((f) => (0, generator_1.quoteIdentifier)(f.column));
+            const placeholders = fields.map((_, idx) => `$${idx + 1}`);
+            const sql = `INSERT INTO ${(0, generator_1.quoteIdentifier)(table)} (${cols.join(', ')}) VALUES (${placeholders.join(', ')}) RETURNING *`;
+            const res = await this.pool.query(sql, fields.map((f) => f.value));
+            return {
+                changes: res.rowCount ?? 1,
+                lastInsertRowid: null,
+            };
+        });
+    }
+    async insertRows(table, rows) {
+        return this.transaction(async (client) => {
+            let inserted = 0;
+            for (const fields of rows) {
+                if (!fields.length)
+                    continue;
+                const cols = fields.map((f) => (0, generator_1.quoteIdentifier)(f.column));
+                const placeholders = fields.map((_, idx) => `$${idx + 1}`);
+                const sql = `INSERT INTO ${(0, generator_1.quoteIdentifier)(table)} (${cols.join(', ')}) VALUES (${placeholders.join(', ')})`;
+                await client.query(sql, fields.map((f) => f.value));
+                inserted++;
+            }
+            return { inserted, skipped: rows.length - inserted };
+        });
+    }
+    async updateRow(table, fields, where) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            const sets = fields.map((f, idx) => `${(0, generator_1.quoteIdentifier)(f.column)} = $${idx + 1}`);
+            const conds = where.map((w, idx) => `${(0, generator_1.quoteIdentifier)(w.column)} = $${fields.length + idx + 1}`);
+            const sql = `UPDATE ${(0, generator_1.quoteIdentifier)(table)} SET ${sets.join(', ')} WHERE ${conds.join(' AND ')}`;
+            const res = await this.pool.query(sql, [...fields.map((f) => f.value), ...where.map((w) => w.value)]);
+            return {
+                changes: res.rowCount ?? 0,
+                lastInsertRowid: null,
+            };
+        });
+    }
+    async updateRows(table, rows) {
+        return this.transaction(async (client) => {
+            let updated = 0;
+            for (const { fields, where } of rows) {
+                if (!fields.length || !where.length)
+                    continue;
+                const sets = fields.map((f, idx) => `${(0, generator_1.quoteIdentifier)(f.column)} = $${idx + 1}`);
+                const conds = where.map((w, idx) => `${(0, generator_1.quoteIdentifier)(w.column)} = $${fields.length + idx + 1}`);
+                const sql = `UPDATE ${(0, generator_1.quoteIdentifier)(table)} SET ${sets.join(', ')} WHERE ${conds.join(' AND ')}`;
+                const res = await client.query(sql, [...fields.map((f) => f.value), ...where.map((w) => w.value)]);
+                updated += res.rowCount ?? 0;
+            }
+            return { updated };
+        });
+    }
+    async deleteRow(table, where) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            const conds = where.map((w, idx) => `${(0, generator_1.quoteIdentifier)(w.column)} = $${idx + 1}`);
+            const sql = `DELETE FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${conds.join(' AND ')}`;
+            const res = await this.pool.query(sql, where.map((w) => w.value));
+            return {
+                changes: res.rowCount ?? 0,
+                lastInsertRowid: null,
+            };
+        });
+    }
+    async deleteRows(table, rows) {
+        return this.transaction(async (client) => {
+            let deleted = 0;
+            for (const where of rows) {
+                if (!where.length)
+                    continue;
+                const conds = where.map((w, idx) => `${(0, generator_1.quoteIdentifier)(w.column)} = $${idx + 1}`);
+                const sql = `DELETE FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${conds.join(' AND ')}`;
+                const res = await client.query(sql, where.map((w) => w.value));
+                deleted += res.rowCount ?? 0;
+            }
+            return { deleted };
+        });
+    }
+    async getRowsByPks(table, pks) {
+        return this.tryRun(async () => {
+            const groups = [];
+            const params = [];
+            let paramIdx = 1;
+            for (const where of pks) {
+                if (!where.length)
+                    continue;
+                const conds = where.map((w) => {
+                    params.push(w.value);
+                    return `${(0, generator_1.quoteIdentifier)(w.column)} = $${paramIdx++}`;
+                });
+                groups.push(conds.join(' AND '));
+            }
+            if (!groups.length)
+                return [];
+            const sql = `SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${groups.map((g) => `(${g})`).join(' OR ')}`;
+            const res = await this.pool.query(sql, params);
+            return res.rows;
+        });
+    }
+    async getRowsByFk(table, column, value, limit = 50) {
+        return this.tryRun(async () => {
+            const n = Math.max(1, Math.min(500, Number(limit) || 50));
+            const countRes = await this.pool.query(`SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${(0, generator_1.quoteIdentifier)(column)} = $1`, [value]);
+            const rowsRes = await this.pool.query(`SELECT * FROM ${(0, generator_1.quoteIdentifier)(table)} WHERE ${(0, generator_1.quoteIdentifier)(column)} = $1 LIMIT $2`, [value, n]);
+            return { rows: rowsRes.rows, total: Number(countRes.rows[0]?.c ?? 0) };
+        });
+    }
+    async getCreateStatement(table) {
+        const info = await this.getTableInfo(table);
+        if (!info.success || !info.data)
+            return { success: false, error: info.error };
+        return { success: true, data: info.data.sql };
+    }
+    async listSavedQueries() {
+        return this.tryRun(async () => {
+            const res = await this.pool.query(`SELECT id, name, sql, created_at FROM ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} ORDER BY name`);
+            return res.rows;
+        });
+    }
+    async saveQuery(name, sql) {
+        return this.tryRun(async () => {
+            const res = await this.pool.query(`INSERT INTO ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} (name, sql) VALUES ($1, $2) RETURNING id`, [name, sql]);
+            return {
+                changes: res.rowCount ?? 1,
+                lastInsertRowid: Number(res.rows[0]?.id ?? null),
+            };
+        });
+    }
+    async deleteSavedQuery(id) {
+        return this.tryRun(async () => {
+            const res = await this.pool.query(`DELETE FROM ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} WHERE id = $1`, [Number(id)]);
+            return {
+                changes: res.rowCount ?? 0,
+                lastInsertRowid: null,
+            };
+        });
+    }
+    async getSchema(table) {
+        return this.tryRun(async () => {
+            const infoR = await this.getTableInfo(table);
+            if (!infoR.success || !infoR.data)
+                throw new Error(infoR.error || `Table ${table} not found.`);
+            const { columns, foreignKeys, indexes, primaryKey } = infoR.data;
+            // Find references in other tables that point to this table
+            const refRes = await this.pool.query(`SELECT
+           tc.table_name AS table,
+           kcu.column_name AS "from",
+           ccu.column_name AS "to"
+         FROM information_schema.table_constraints AS tc
+         JOIN information_schema.key_column_usage AS kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+         JOIN information_schema.constraint_column_usage AS ccu
+           ON ccu.constraint_name = tc.constraint_name
+           AND ccu.table_schema = tc.table_schema
+         WHERE tc.constraint_type = 'FOREIGN KEY'
+           AND tc.table_schema = $1
+           AND ccu.table_name = $2;`, [this.schema, table]);
+            const references = refRes.rows;
+            const columnDetails = columns.map((col) => {
+                const isPk = primaryKey.includes(col.name);
+                const fk = foreignKeys.find((f) => f.from === col.name) ?? null;
+                const matchingIndexes = indexes.filter((i) => i.columns.includes(col.name));
+                const unique = matchingIndexes.some((i) => i.unique && i.columns.length === 1 && i.columns[0] === col.name);
+                const indexed = matchingIndexes.length > 0;
+                const referencedBy = references
+                    .filter((r) => r.to === col.name)
+                    .map((r) => ({ table: r.table, from: r.from }));
+                const dropBlockers = [];
+                if (isPk && primaryKey.length === 1)
+                    dropBlockers.push('Primary key');
+                if (referencedBy.length > 0) {
+                    dropBlockers.push(`Referenced by ${referencedBy.map((r) => `${r.table}.${r.from}`).join(', ')}`);
+                }
+                return {
+                    ...col,
+                    unique,
+                    indexed,
+                    referencedBy,
+                    fk,
+                    canDrop: dropBlockers.length === 0,
+                    dropBlockers,
+                };
+            });
+            return {
+                table,
+                columns: columnDetails,
+                foreignKeys,
+                indexes,
+                references,
+            };
+        });
+    }
+    async getReferencingTables(table) {
+        return this.tryRun(async () => {
+            const refRes = await this.pool.query(`SELECT
+           tc.table_name AS table,
+           kcu.column_name AS "from",
+           ccu.column_name AS "to"
+         FROM information_schema.table_constraints AS tc
+         JOIN information_schema.key_column_usage AS kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+         JOIN information_schema.constraint_column_usage AS ccu
+           ON ccu.constraint_name = tc.constraint_name
+           AND ccu.table_schema = tc.table_schema
+         WHERE tc.constraint_type = 'FOREIGN KEY'
+           AND tc.table_schema = $1
+           AND ccu.table_name = $2;`, [this.schema, table]);
+            const byTable = new Map();
+            for (const r of refRes.rows) {
+                if (!byTable.has(r.table))
+                    byTable.set(r.table, []);
+                byTable.get(r.table).push({ from: r.from, to: r.to });
+            }
+            const results = [];
+            for (const [tbl, refs] of byTable.entries()) {
+                try {
+                    const countRes = await this.pool.query(`SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(tbl)} WHERE ${refs.map((r) => `${(0, generator_1.quoteIdentifier)(r.from)} IS NOT NULL`).join(' OR ')}`);
+                    results.push({
+                        table: tbl,
+                        refs,
+                        refCount: Number(countRes.rows[0]?.c ?? 0),
+                    });
+                }
+                catch {
+                    results.push({ table: tbl, refs, refCount: 0 });
+                }
+            }
+            return results;
+        });
+    }
+    async renameTable(oldName, newName) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(oldName)} RENAME TO ${(0, generator_1.quoteIdentifier)(newName)};`);
+            return { changes: 1 };
+        });
+    }
+    async addColumn(table, col) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            let sql = `ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ADD COLUMN ${(0, generator_1.quoteIdentifier)(col.name)} ${col.type}`;
+            if (col.notNull)
+                sql += ' NOT NULL';
+            if (col.defaultValue !== undefined && col.defaultValue !== null && col.defaultValue !== '') {
+                sql += ` DEFAULT ${col.defaultValue}`;
+            }
+            if (col.foreignKey) {
+                sql += ` REFERENCES ${(0, generator_1.quoteIdentifier)(col.foreignKey.table)} (${(0, generator_1.quoteIdentifier)(col.foreignKey.column)})`;
+            }
+            await this.pool.query(sql);
+            if (col.unique) {
+                const idxName = `idx_${table}_${col.name}_unique`;
+                await this.pool.query(`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 };
+        });
+    }
+    async modifyColumn(table, oldColName, newColDef) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            const newName = String(newColDef.name || oldColName).trim();
+            // Rename column first if name changed
+            if (oldColName !== newName) {
+                await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} RENAME COLUMN ${(0, generator_1.quoteIdentifier)(oldColName)} TO ${(0, generator_1.quoteIdentifier)(newName)};`);
+            }
+            const colToModify = newName;
+            // Alter Type if provided
+            if (newColDef.type) {
+                await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} TYPE ${newColDef.type} USING ${(0, generator_1.quoteIdentifier)(colToModify)}::${newColDef.type};`);
+            }
+            // Alter NOT NULL
+            if (newColDef.notNull !== undefined) {
+                const action = newColDef.notNull ? 'SET NOT NULL' : 'DROP NOT NULL';
+                await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} ${action};`);
+            }
+            // Alter DEFAULT
+            if (newColDef.defaultValue !== undefined) {
+                if (newColDef.defaultValue === null || newColDef.defaultValue === '') {
+                    await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} DROP DEFAULT;`);
+                }
+                else {
+                    await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} SET DEFAULT ${newColDef.defaultValue};`);
+                }
+            }
+            // Handle unique index
+            if (newColDef.unique !== undefined) {
+                const idxName = `idx_${table}_${colToModify}_unique`;
+                if (newColDef.unique) {
+                    await this.pool.query(`CREATE UNIQUE INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(idxName)} ON ${(0, generator_1.quoteIdentifier)(table)} (${(0, generator_1.quoteIdentifier)(colToModify)});`);
+                }
+                else {
+                    await this.pool.query(`DROP INDEX IF EXISTS ${(0, generator_1.quoteIdentifier)(idxName)};`);
+                }
+            }
+            return { changes: 1 };
+        });
+    }
+    async renameColumn(table, oldName, newName) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} RENAME COLUMN ${(0, generator_1.quoteIdentifier)(oldName)} TO ${(0, generator_1.quoteIdentifier)(newName)};`);
+            return { changes: 1 };
+        });
+    }
+    async dropColumn(table, column) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} DROP COLUMN ${(0, generator_1.quoteIdentifier)(column)} CASCADE;`);
+            return { changes: 1 };
+        });
+    }
+    async dropTable(table) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            await this.pool.query(`DROP TABLE ${(0, generator_1.quoteIdentifier)(table)} CASCADE;`);
+            return { changes: 1 };
+        });
+    }
+    async createIndex(table, index) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            const unique = index.unique ? 'UNIQUE ' : '';
+            const cols = index.columns.map(generator_1.quoteIdentifier).join(', ');
+            const name = index.name || `idx_${table}_${index.columns.join('_')}`;
+            await this.pool.query(`CREATE ${unique}INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(name)} ON ${(0, generator_1.quoteIdentifier)(table)} (${cols});`);
+            return { changes: 1 };
+        });
+    }
+    async dropIndex(indexName) {
+        if (this.isReadOnly)
+            return this.readonlyBlocked();
+        return this.tryRun(async () => {
+            await this.pool.query(`DROP INDEX IF EXISTS ${(0, generator_1.quoteIdentifier)(indexName)} CASCADE;`);
+            return { changes: 1 };
+        });
+    }
+}
+exports.PostgresDatabase = PostgresDatabase;
+//# sourceMappingURL=postgres.js.map