admindb 2.4.0 → 2.5.0

package/dist/db/dialects/postgres/introspector.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresIntrospector = void 0;
+const generator_1 = require("../../../sql/generator");
+class PostgresIntrospector {
+    schema;
+    constructor(schema = 'public') {
+        this.schema = schema;
+    }
+    getPool(driver) {
+        if (driver && typeof driver === 'object' && 'pool' in driver) {
+            return driver.pool;
+        }
+        return driver;
+    }
+    async listTables(driver) {
+        try {
+            const pool = this.getPool(driver);
+            const res = await pool.query(`SELECT table_name
+         FROM information_schema.tables
+         WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+         ORDER BY table_name;`, [this.schema]);
+            return { success: true, data: res.rows.map((r) => ({ name: r.table_name })) };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getColumnCountMap(driver) {
+        try {
+            const pool = this.getPool(driver);
+            const colRes = await pool.query(`SELECT table_name, count(*)::int AS cols FROM information_schema.columns WHERE table_schema = $1 GROUP BY table_name;`, [this.schema]);
+            const map = {};
+            for (const row of colRes.rows) {
+                if (row && typeof row.table_name === 'string') {
+                    map[row.table_name] = Number(row.cols ?? 0);
+                }
+            }
+            return { success: true, data: map };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getTableInfo(driver, table) {
+        try {
+            const pool = this.getPool(driver);
+            const colRes = await pool.query(`SELECT ordinal_position, column_name, data_type, udt_name, is_nullable, column_default
+         FROM information_schema.columns
+         WHERE table_schema = $1 AND table_name = $2
+         ORDER BY ordinal_position;`, [this.schema, table]);
+            if (!colRes.rows.length) {
+                return { success: false, error: `Table "${table}" does not exist.` };
+            }
+            const pkRes = await 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]);
+            const primaryKey = pkRes.rows.map((r) => r.column_name);
+            const columns = colRes.rows.map((r) => {
+                const pkIdx = primaryKey.indexOf(r.column_name);
+                const colType = r.data_type === 'USER-DEFINED' ? r.udt_name : (r.udt_name || r.data_type).toUpperCase();
+                return {
+                    cid: r.ordinal_position,
+                    name: r.column_name,
+                    type: colType,
+                    notnull: r.is_nullable === 'NO' ? 1 : 0,
+                    dflt_value: r.column_default,
+                    pk: pkIdx >= 0 ? pkIdx + 1 : 0,
+                };
+            });
+            const fkRes = await pool.query(`SELECT
+           row_number() OVER () AS id,
+           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
+         WHERE tc.constraint_type = 'FOREIGN KEY'
+           AND tc.table_schema = $1
+           AND tc.table_name = $2;`, [this.schema, table]);
+            const foreignKeys = fkRes.rows.map((r, idx) => ({
+                id: Number(r.id || idx + 1),
+                seq: idx,
+                table: r.table,
+                from: r.from,
+                to: r.to,
+                on_update: r.on_update,
+                on_delete: r.on_delete,
+            }));
+            const idxRes = await pool.query(`SELECT
+           i.relname AS indexname,
+           ix.indisunique,
+           ix.indisprimary,
+           array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) AS columns,
+           pg_get_indexdef(ix.indexrelid) AS indexdef
+         FROM pg_class t
+         JOIN pg_index ix ON t.oid = ix.indrelid
+         JOIN pg_class i ON i.oid = ix.indexrelid
+         JOIN pg_namespace n ON n.oid = t.relnamespace
+         JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+         WHERE n.nspname = $1 AND t.relname = $2
+         GROUP BY i.relname, ix.indisunique, ix.indisprimary, ix.indexrelid;`, [this.schema, table]);
+            const indexes = idxRes.rows.map((r) => ({
+                name: r.indexname,
+                unique: Boolean(r.indisunique),
+                partial: 0,
+                origin: r.indisprimary ? 'pk' : r.indisunique ? 'u' : 'c',
+                columns: r.columns || [],
+                sql: r.indexdef,
+            }));
+            const ddlCols = 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) {
+                ddlCols.push(`  PRIMARY KEY (${primaryKey.map(generator_1.quoteIdentifier).join(', ')})`);
+            }
+            for (const fk of foreignKeys) {
+                ddlCols.push(`  FOREIGN KEY (${(0, generator_1.quoteIdentifier)(fk.from)}) REFERENCES ${(0, generator_1.quoteIdentifier)(fk.table)}(${(0, generator_1.quoteIdentifier)(fk.to || fk.from)})`);
+            }
+            const fakeSql = `CREATE TABLE ${(0, generator_1.quoteIdentifier)(table)} (\n${ddlCols.join(',\n')}\n);`;
+            return {
+                success: true,
+                data: {
+                    table,
+                    columns,
+                    foreignKeys,
+                    primaryKey,
+                    indexes,
+                    sql: fakeSql,
+                },
+            };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getSchema(driver, table) {
+        try {
+            const pool = this.getPool(driver);
+            const infoR = await this.getTableInfo(driver, table);
+            if (!infoR.success || !infoR.data)
+                throw new Error(infoR.error || `Table ${table} not found.`);
+            const { columns, foreignKeys, indexes, primaryKey } = infoR.data;
+            const refRes = await 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 {
+                success: true,
+                data: {
+                    table,
+                    columns: columnDetails,
+                    foreignKeys,
+                    indexes,
+                    references,
+                },
+            };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getReferencingTables(driver, table) {
+        try {
+            const pool = this.getPool(driver);
+            const refRes = await 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 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 { success: true, data: results };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getCreateStatement(driver, table) {
+        const info = await this.getTableInfo(driver, table);
+        if (!info.success || !info.data)
+            return { success: false, error: info.error };
+        return { success: true, data: info.data.sql };
+    }
+}
+exports.PostgresIntrospector = PostgresIntrospector;

package/dist/db/dialects/postgres/types.d.ts

@@ -0,0 +1 @@
+export declare const POSTGRES_DESIGNER_TYPES:readonly ["TEXT","VARCHAR(255)","INTEGER","BIGINT","SMALLINT","SERIAL","BIGSERIAL","REAL","DECIMAL(10,2)","NUMERIC","BOOLEAN","DATE","DATETIME","TIMESTAMP","TIMESTAMPTZ","TIME","INTERVAL","JSON","JSONB","UUID","BYTEA","INET"];import type {MappedType} from '../types';export type {MappedType};export declare function mapPostgresColumnType(type:string):MappedType;

package/dist/db/dialects/postgres/types.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POSTGRES_DESIGNER_TYPES = void 0;
+exports.mapPostgresColumnType = mapPostgresColumnType;
+exports.POSTGRES_DESIGNER_TYPES = [
+    'TEXT',
+    'VARCHAR(255)',
+    'INTEGER',
+    'BIGINT',
+    'SMALLINT',
+    'SERIAL',
+    'BIGSERIAL',
+    'REAL',
+    'DECIMAL(10,2)',
+    'NUMERIC',
+    'BOOLEAN',
+    'DATE',
+    'DATETIME',
+    'TIMESTAMP',
+    'TIMESTAMPTZ',
+    'TIME',
+    'INTERVAL',
+    'JSON',
+    'JSONB',
+    'UUID',
+    'BYTEA',
+    'INET',
+];
+function mapPostgresColumnType(type) {
+    const t = String(type ?? '').trim().toUpperCase();
+    if (!t)
+        return { sqlType: 'TEXT' };
+    switch (t) {
+        case 'INT':
+        case 'INTEGER':
+            return { sqlType: 'INTEGER' };
+        case 'BIGINT':
+        case 'SMALLINT':
+        case 'SERIAL':
+        case 'BIGSERIAL':
+        case 'SMALLSERIAL':
+            return { sqlType: t };
+        case 'TEXT':
+        case 'VARCHAR':
+        case 'CHAR':
+        case 'CITEXT':
+            return { sqlType: 'TEXT' };
+        case 'REAL':
+        case 'FLOAT':
+        case 'DOUBLE PRECISION':
+        case 'DECIMAL':
+        case 'NUMERIC':
+        case 'MONEY':
+            return { sqlType: 'NUMERIC' };
+        case 'BYTEA':
+        case 'BLOB':
+            return { sqlType: 'BYTEA' };
+        case 'BOOLEAN':
+        case 'BOOL':
+            return { sqlType: 'BOOLEAN' };
+        case 'DATE':
+            return { sqlType: 'DATE', defaultAuto: 'CURRENT_DATE' };
+        case 'DATETIME':
+        case 'TIMESTAMP':
+            return { sqlType: 'TIMESTAMP' };
+        case 'TIMESTAMPTZ':
+            return { sqlType: 'TIMESTAMPTZ', defaultAuto: 'CURRENT_TIMESTAMP' };
+        case 'TIME':
+        case 'TIMETZ':
+        case 'INTERVAL':
+        case 'JSON':
+        case 'JSONB':
+        case 'UUID':
+        case 'INET':
+        case 'CIDR':
+        case 'MACADDR':
+            return { sqlType: t };
+        default:
+            if (/^[A-Za-z0-9_(),\s\[\]]+$/.test(t))
+                return { sqlType: t };
+            return { sqlType: 'TEXT' };
+    }
+}

package/dist/db/dialects/sqlite/ddl.d.ts

@@ -0,0 +1 @@
+import{type ColumnDef,type IndexDef} from '../../../sql/generator';import type {IDdlGenerator} from '../types';import type {Result} from '../../types';export declare function renderSqliteColumnDef(col:ColumnDef,opts?:{forAddColumn?:boolean;}):string;export declare class SqliteDdlGenerator implements IDdlGenerator{createTable(tableName:string,columns:ColumnDef[]):string;renameTable(oldName:string,newName:string):string;dropTable(table:string,options?:{cascade?:boolean;ifExists?:boolean;}):string;truncateTable(table:string,_options?:{cascade?:boolean;restartIdentity?:boolean;}):string;setForeignKeys(enabled:boolean):string;addColumn(table:string,col:ColumnDef):string;renameColumn(table:string,oldName:string,newName:string):string;dropColumn(table:string,column:string):string;createIndex(table:string,index:IndexDef):string;dropIndex(indexName:string):string;modifyColumn(driver:unknown,table:string,oldCol:string,newCol:ColumnDef):Promise<Result<{changes?:number;}>>;}

package/dist/db/dialects/sqlite/ddl.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteDdlGenerator = void 0;
+exports.renderSqliteColumnDef = renderSqliteColumnDef;
+const generator_1 = require("../../../sql/generator");
+const types_1 = require("./types");
+const IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_$]*$/;
+function validateIdentifier(kind, name) {
+    const label = kind.charAt(0).toUpperCase() + kind.slice(1);
+    const trimmed = String(name ?? '').trim();
+    if (!trimmed)
+        throw new Error(`${label} name is required.`);
+    if (!IDENTIFIER_RE.test(trimmed)) {
+        throw new Error(`Invalid ${label.toLowerCase()} name: "${trimmed}". Use letters, digits and underscores.`);
+    }
+}
+function formatSqlDefault(raw, colType) {
+    const s = String(raw ?? '').trim().replace(/;/g, '');
+    if (!s)
+        return '';
+    if (/^null$/i.test(s))
+        return 'NULL';
+    if (/^[-+]?\d+(\.\d+)?$/.test(s))
+        return s;
+    if (/^(true|false)$/i.test(s))
+        return s.toUpperCase() === 'TRUE' ? '1' : '0';
+    if (/^'.*'$/s.test(s) || /^".*"$/s.test(s) || /^[a-zA-Z_]\w*\s*\(.*\)$/s.test(s))
+        return s;
+    if (/^CURRENT_TIMESTAMP|CURRENT_DATE|CURRENT_TIME$/i.test(s))
+        return s.toUpperCase();
+    const t = (colType || '').toUpperCase();
+    if (t.includes('TEXT') || t.includes('CHAR') || t.includes('CLOB') || t.includes('VARCHAR') || t.includes('STRING')) {
+        return (0, generator_1.escapeString)(s);
+    }
+    return s;
+}
+function renderSqliteColumnDef(col, opts = {}) {
+    const colName = String(col?.name ?? '').trim();
+    validateIdentifier('column', colName);
+    const mapped = (0, types_1.mapSqliteColumnType)(col.type);
+    if (opts.forAddColumn) {
+        if (col.primaryKey) {
+            throw new Error(`Cannot add "${colName}" as PRIMARY KEY: ALTER TABLE ADD COLUMN does not support primary keys.`);
+        }
+        if (col.unique) {
+            throw new Error(`Cannot add "${colName}" with UNIQUE: ALTER TABLE ADD COLUMN does not support UNIQUE constraints.`);
+        }
+    }
+    let def = `${(0, generator_1.quoteIdentifier)(colName)} ${mapped.sqlType}`;
+    if (!opts.forAddColumn && col.primaryKey)
+        def += ' PRIMARY KEY';
+    if (col.notNull)
+        def += ' NOT NULL';
+    if (!opts.forAddColumn && col.unique)
+        def += ' UNIQUE';
+    const rawDefault = formatSqlDefault(String(col.defaultValue ?? ''), col.type);
+    const dflt = rawDefault || mapped.defaultAuto || '';
+    if (dflt) {
+        def += ` DEFAULT ${dflt}`;
+    }
+    else if (opts.forAddColumn && col.notNull) {
+        throw new Error(`Cannot add "${colName}" as NOT NULL without a default value.`);
+    }
+    if (col.foreignKey?.table && col.foreignKey.column) {
+        if (opts.forAddColumn && (col.notNull || dflt)) {
+            throw new Error(`Cannot add "${colName}" as a foreign key with NOT NULL or a non-NULL default.`);
+        }
+        def += ` REFERENCES ${(0, generator_1.quoteIdentifier)(col.foreignKey.table)}(${(0, generator_1.quoteIdentifier)(col.foreignKey.column)})`;
+    }
+    return def;
+}
+class SqliteDdlGenerator {
+    createTable(tableName, columns) {
+        const table = String(tableName ?? '').trim();
+        validateIdentifier('table', table);
+        if (!Array.isArray(columns) || columns.length === 0) {
+            throw new Error('At least one column is required.');
+        }
+        const seen = new Set();
+        let pkCount = 0;
+        const parts = [];
+        for (const col of columns) {
+            const colName = String(col?.name ?? '').trim();
+            validateIdentifier('column', colName);
+            if (seen.has(colName))
+                throw new Error(`Duplicate column name: "${colName}".`);
+            seen.add(colName);
+            if (col.primaryKey)
+                pkCount++;
+            parts.push(renderSqliteColumnDef(col));
+        }
+        if (pkCount > 1)
+            throw new Error('At most one primary key column is allowed.');
+        return `CREATE TABLE ${(0, generator_1.quoteIdentifier)(table)} (\n  ${parts.join(',\n  ')}\n);`;
+    }
+    renameTable(oldName, newName) {
+        validateIdentifier('table', oldName);
+        validateIdentifier('table', newName);
+        return `ALTER TABLE ${(0, generator_1.quoteIdentifier)(oldName)} RENAME TO ${(0, generator_1.quoteIdentifier)(newName)};`;
+    }
+    dropTable(table, options) {
+        validateIdentifier('table', table);
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        return `DROP TABLE ${ifExists}${(0, generator_1.quoteIdentifier)(table)};`;
+    }
+    truncateTable(table, _options) {
+        validateIdentifier('table', table);
+        return `DELETE FROM ${(0, generator_1.quoteIdentifier)(table)};`;
+    }
+    setForeignKeys(enabled) {
+        return `PRAGMA foreign_keys = ${enabled ? 'ON' : 'OFF'};`;
+    }
+    addColumn(table, col) {
+        validateIdentifier('table', table);
+        return `ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ADD COLUMN ${renderSqliteColumnDef(col, { forAddColumn: true })};`;
+    }
+    renameColumn(table, oldName, newName) {
+        validateIdentifier('table', table);
+        validateIdentifier('column', oldName);
+        validateIdentifier('column', newName);
+        return `ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} RENAME COLUMN ${(0, generator_1.quoteIdentifier)(oldName)} TO ${(0, generator_1.quoteIdentifier)(newName)};`;
+    }
+    dropColumn(table, column) {
+        validateIdentifier('table', table);
+        validateIdentifier('column', column);
+        return `ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} DROP COLUMN ${(0, generator_1.quoteIdentifier)(column)};`;
+    }
+    createIndex(table, index) {
+        const unique = index.unique ? 'UNIQUE ' : '';
+        const cols = index.columns.map(generator_1.quoteIdentifier).join(', ');
+        const name = index.name || `idx_${table}_${index.columns.join('_')}`;
+        return `CREATE ${unique}INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(name)} ON ${(0, generator_1.quoteIdentifier)(table)} (${cols});`;
+    }
+    dropIndex(indexName) {
+        return `DROP INDEX IF EXISTS ${(0, generator_1.quoteIdentifier)(indexName)};`;
+    }
+    async modifyColumn(driver, table, oldCol, newCol) {
+        try {
+            const db = (driver && typeof driver === 'object' && 'db' in driver)
+                ? driver.db
+                : driver;
+            const rawCols = db.prepare(`PRAGMA table_info(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            if (!rawCols.length)
+                throw new Error(`Table "${table}" does not exist.`);
+            const fks = db.prepare(`PRAGMA foreign_key_list(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            const indexRows = db
+                .prepare(`PRAGMA index_list(${(0, generator_1.quoteIdentifier)(table)})`)
+                .all();
+            const uniqueCols = new Set();
+            for (const ix of indexRows) {
+                if (ix.unique) {
+                    const ixCols = db.prepare(`PRAGMA index_info(${(0, generator_1.quoteIdentifier)(ix.name)})`).all().map((c) => c.name);
+                    if (ixCols.length === 1)
+                        uniqueCols.add(ixCols[0]);
+                }
+            }
+            const userIndexes = [];
+            for (const ix of indexRows) {
+                if (ix.origin === 'c') {
+                    const ixCols = db.prepare(`PRAGMA index_info(${(0, generator_1.quoteIdentifier)(ix.name)})`).all().map((c) => c.name);
+                    let ixName = ix.name;
+                    const renamedNewCol = newCol.name;
+                    if (oldCol && renamedNewCol) {
+                        if (ixName === `idx_${table}_${oldCol}`) {
+                            ixName = `idx_${table}_${renamedNewCol}`;
+                        }
+                        else if (ixName === `idx_${table}_${oldCol}_unique`) {
+                            ixName = `idx_${table}_${renamedNewCol}_unique`;
+                        }
+                    }
+                    userIndexes.push({
+                        name: ixName,
+                        unique: Boolean(ix.unique),
+                        columns: ixCols.map((c) => (oldCol && renamedNewCol && c === oldCol ? renamedNewCol : c)),
+                    });
+                }
+            }
+            const currentCols = rawCols.map((c) => {
+                const existingFk = fks.find((f) => f.from === c.name);
+                return {
+                    name: c.name,
+                    type: c.type,
+                    primaryKey: c.pk > 0,
+                    notNull: Boolean(c.notnull),
+                    unique: uniqueCols.has(c.name),
+                    defaultValue: c.dflt_value,
+                    foreignKey: existingFk ? { table: existingFk.table, column: existingFk.to ?? '' } : null,
+                };
+            });
+            const newCols = currentCols.map((c) => (c.name === oldCol ? { ...c, ...newCol } : c));
+            const tempTable = `_admindb_tmp_${table}_${Date.now()}`;
+            const createSql = this.createTable(tempTable, newCols);
+            const oldColMap = new Set(rawCols.map((c) => c.name));
+            const matchingOldCols = [];
+            const matchingNewCols = [];
+            for (const nc of newCols) {
+                const sourceColName = oldCol && newCol.name && nc.name === newCol.name ? oldCol : nc.name;
+                if (oldColMap.has(sourceColName)) {
+                    matchingOldCols.push((0, generator_1.quoteIdentifier)(sourceColName));
+                    matchingNewCols.push((0, generator_1.quoteIdentifier)(nc.name));
+                }
+            }
+            db.exec('PRAGMA foreign_keys = OFF;\nBEGIN TRANSACTION;');
+            try {
+                db.exec(createSql);
+                if (matchingOldCols.length > 0) {
+                    db.exec(`INSERT INTO ${(0, generator_1.quoteIdentifier)(tempTable)} (${matchingNewCols.join(', ')}) SELECT ${matchingOldCols.join(', ')} FROM ${(0, generator_1.quoteIdentifier)(table)};`);
+                }
+                db.exec(`DROP TABLE ${(0, generator_1.quoteIdentifier)(table)};`);
+                db.exec(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(tempTable)} RENAME TO ${(0, generator_1.quoteIdentifier)(table)};`);
+                for (const ix of userIndexes) {
+                    const uq = ix.unique ? 'UNIQUE ' : '';
+                    const ixColsStr = ix.columns.map(generator_1.quoteIdentifier).join(', ');
+                    try {
+                        db.exec(`CREATE ${uq}INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(ix.name)} ON ${(0, generator_1.quoteIdentifier)(table)} (${ixColsStr});`);
+                    }
+                    catch { }
+                }
+                if (db.prepare('PRAGMA foreign_key_check;').all().length > 0) {
+                    throw new Error('Foreign key constraint check failed after schema modification.');
+                }
+                db.exec('COMMIT;');
+                return { success: true, data: { changes: 1 } };
+            }
+            catch (err) {
+                try {
+                    db.exec('ROLLBACK;');
+                }
+                catch { }
+                throw err;
+            }
+            finally {
+                try {
+                    db.exec('PRAGMA foreign_keys = ON;');
+                }
+                catch { }
+            }
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+}
+exports.SqliteDdlGenerator = SqliteDdlGenerator;

package/dist/db/dialects/sqlite/dialect.d.ts

@@ -0,0 +1 @@
+import type {DialectCapabilities,IDialect} from '../types';import{SqliteDdlGenerator} from './ddl';import{SqliteIntrospector} from './introspector';export declare class SqliteDialect implements IDialect{readonly name:"sqlite";readonly capabilities:DialectCapabilities;readonly introspector:SqliteIntrospector;readonly ddl:SqliteDdlGenerator;quoteIdentifier(identifier:string):string;mapType(type:string):import("./types").MappedType;getDesignerTypes():readonly string[];}export declare const sqliteDialect:SqliteDialect;

package/dist/db/dialects/sqlite/dialect.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqliteDialect = exports.SqliteDialect = void 0;
+const generator_1 = require("../../../sql/generator");
+const types_1 = require("../types");
+const ddl_1 = require("./ddl");
+const introspector_1 = require("./introspector");
+const types_2 = require("./types");
+class SqliteDialect {
+    name = 'sqlite';
+    capabilities = types_1.SQLITE_CAPABILITIES;
+    introspector = new introspector_1.SqliteIntrospector();
+    ddl = new ddl_1.SqliteDdlGenerator();
+    quoteIdentifier(identifier) {
+        return (0, generator_1.quoteIdentifier)(identifier);
+    }
+    mapType(type) {
+        return (0, types_2.mapSqliteColumnType)(type);
+    }
+    getDesignerTypes() {
+        return types_2.SQLITE_DESIGNER_TYPES;
+    }
+}
+exports.SqliteDialect = SqliteDialect;
+exports.sqliteDialect = new SqliteDialect();

package/dist/db/dialects/sqlite/introspector.d.ts

@@ -0,0 +1 @@
+import type {ISchemaIntrospector} from '../types';import type {ReferencingTableInfo,Result,SchemaInfo,TableInfoData,TableListItem} from '../../types';export declare class SqliteIntrospector implements ISchemaIntrospector{private getNativeDb;listTables(driver:unknown):Promise<Result<TableListItem[]>>;private getTableNames;private getIncomingFks;getTableInfo(driver:unknown,table:string):Promise<Result<TableInfoData>>;getSchema(driver:unknown,table:string):Promise<Result<SchemaInfo>>;getReferencingTables(driver:unknown,table:string):Promise<Result<ReferencingTableInfo[]>>;getCreateStatement(driver:unknown,table:string):Promise<Result<string|null>>;}