admindb 2.4.1 → 2.6.0

package/dist/core/transfer/masking.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MASKING_RULES = void 0;
+exports.maskRowData = maskRowData;
+exports.DEFAULT_MASKING_RULES = [
+    { columnPattern: 'email|e_mail|mail', strategy: 'email' },
+    { columnPattern: 'pass|password|passwd|pwd|secret|token|api_key|auth', strategy: 'password' },
+    { columnPattern: 'phone|mobile|cell|telephone', strategy: 'phone' },
+    { columnPattern: 'first_name|last_name|full_name|username|user_name', strategy: 'name' },
+];
+function maskRowData(row, rules = exports.DEFAULT_MASKING_RULES, rowIndex = 1) {
+    const masked = { ...row };
+    for (const [colName, val] of Object.entries(row)) {
+        if (val === null || val === undefined)
+            continue;
+        for (const rule of rules) {
+            const regex = new RegExp(rule.columnPattern, 'i');
+            if (regex.test(colName)) {
+                switch (rule.strategy) {
+                    case 'email':
+                        masked[colName] = `user${rowIndex}@masked.test`;
+                        break;
+                    case 'password':
+                        if (/token|secret|key|auth/i.test(colName) && !/pass|pwd/i.test(colName)) {
+                            masked[colName] = `masked_${rowIndex}_${Math.random().toString(36).substring(2, 10)}${Math.random().toString(36).substring(2, 10)}`;
+                        }
+                        else {
+                            masked[colName] = `$2b$10$maskedpwdhash${String(rowIndex).padStart(6, '0')}${Math.random().toString(36).substring(2, 14)}`;
+                        }
+                        break;
+                    case 'phone':
+                        masked[colName] = `+1555000${String(rowIndex).padStart(4, '0')}`;
+                        break;
+                    case 'name':
+                        masked[colName] = `Test User ${rowIndex}`;
+                        break;
+                    case 'redact':
+                        masked[colName] = `[REDACTED_${rowIndex}]`;
+                        break;
+                    case 'hash':
+                        masked[colName] = `hash_${rowIndex}_${Math.random().toString(36).substring(2, 8)}`;
+                        break;
+                }
+                break;
+            }
+        }
+    }
+    return masked;
+}

package/dist/core/transfer/sync-engine.d.ts

@@ -0,0 +1 @@
+import type {IDatabase} from '../../db/types';import{type MaskingRule} from './masking';export type SyncMode='full'|'schema_only'|'data_only_replace'|'data_only_upsert';export interface SyncOptions{tables?:string[];mode?:SyncMode;maskData?:boolean;maskRules?:MaskingRule[];batchSize?:number;dryRun?:boolean;}export interface SyncTableProgress{table:string;rowsCopied:number;totalRows:number;status:'pending'|'in_progress'|'completed'|'skipped'|'failed';error?:string;}export interface SyncResult{success:boolean;dryRun:boolean;sourceDbId:string;targetDbId:string;mode:SyncMode;tablesProcessed:SyncTableProgress[];totalRowsTransferred:number;executionTimeMs:number;error?:string;summary:string;}export declare function executeSync(sourceDb:IDatabase,sourceDbId:string,targetDb:IDatabase,targetDbId:string,options?:SyncOptions):Promise<SyncResult>;

package/dist/core/transfer/sync-engine.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeSync = executeSync;
+const dialect_mapper_1 = require("./dialect-mapper");
+const topological_sort_1 = require("./topological-sort");
+const masking_1 = require("./masking");
+async function executeSync(sourceDb, sourceDbId, targetDb, targetDbId, options = {}) {
+    const startTime = Date.now();
+    const mode = options.mode || 'full';
+    const batchSize = Math.max(50, options.batchSize || 500);
+    const dryRun = Boolean(options.dryRun);
+    const maskData = Boolean(options.maskData);
+    const sourceDialect = sourceDb.dialect === 'postgres' ? 'postgres' : 'sqlite';
+    const targetDialect = targetDb.dialect === 'postgres' ? 'postgres' : 'sqlite';
+    const srcTableListRes = await sourceDb.listTables();
+    if (!srcTableListRes.success)
+        throw new Error(srcTableListRes.error || 'Failed to list source tables');
+    let tablesToSync = (srcTableListRes.data || [])
+        .map((t) => t.name)
+        .filter((n) => !n.startsWith('sqlite_') && !n.startsWith('_admindb_'));
+    if (options.tables && options.tables.length > 0) {
+        const selected = new Set(options.tables);
+        tablesToSync = tablesToSync.filter((n) => selected.has(n));
+    }
+    const sourceTableInfos = [];
+    for (const name of tablesToSync) {
+        const infoRes = await sourceDb.getTableInfo(name);
+        if (infoRes.success && infoRes.data) {
+            sourceTableInfos.push(infoRes.data);
+        }
+    }
+    const deps = sourceTableInfos.map((i) => ({
+        name: i.table,
+        foreignKeys: i.foreignKeys || [],
+    }));
+    const insertionOrder = (0, topological_sort_1.sortTablesTopologically)(deps);
+    const deletionOrder = (0, topological_sort_1.sortTablesForDeletion)(deps);
+    const normalizedTables = new Map();
+    for (const info of sourceTableInfos) {
+        normalizedTables.set(info.table, (0, dialect_mapper_1.normalizeTableInfo)(info, sourceDialect));
+    }
+    const progressList = insertionOrder.map((name) => ({
+        table: name,
+        rowsCopied: 0,
+        totalRows: 0,
+        status: 'pending',
+    }));
+    if (dryRun) {
+        let totalEstimatedRows = 0;
+        for (const p of progressList) {
+            const countRes = await sourceDb.getRowCount(p.table);
+            p.totalRows = countRes.data || 0;
+            p.rowsCopied = mode === 'schema_only' ? 0 : p.totalRows;
+            p.status = 'completed';
+            totalEstimatedRows += p.rowsCopied;
+        }
+        return {
+            success: true,
+            dryRun: true,
+            sourceDbId,
+            targetDbId,
+            mode,
+            tablesProcessed: progressList,
+            totalRowsTransferred: totalEstimatedRows,
+            executionTimeMs: Date.now() - startTime,
+            summary: `Dry Run: Ready to sync ${progressList.length} tables (${totalEstimatedRows} estimated rows) from "${sourceDbId}" to "${targetDbId}".`,
+        };
+    }
+    let totalRowsTransferred = 0;
+    try {
+        if (targetDialect === 'sqlite') {
+            await targetDb.execResult('PRAGMA foreign_keys = OFF;');
+        }
+        else {
+            try {
+                await targetDb.execResult('SET CONSTRAINTS ALL DEFERRED;');
+            }
+            catch { }
+        }
+    }
+    catch { }
+    try {
+        if (mode === 'full') {
+            for (const tableName of deletionOrder) {
+                try {
+                    await targetDb.execResult(targetDialect === 'postgres'
+                        ? `DROP TABLE IF EXISTS "${tableName}" CASCADE;`
+                        : `DROP TABLE IF EXISTS \`${tableName}\`;`);
+                }
+                catch { }
+            }
+            for (const tableName of insertionOrder) {
+                const norm = normalizedTables.get(tableName);
+                if (!norm)
+                    continue;
+                const ddl = (0, dialect_mapper_1.generateCreateTableForDialect)(norm, targetDialect);
+                const createRes = await targetDb.execResult(ddl);
+                if (!createRes.success) {
+                    throw new Error(`Failed to create table "${tableName}": ${createRes.error}`);
+                }
+                for (const idx of norm.indexes || []) {
+                    if (idx.name?.startsWith('sqlite_'))
+                        continue;
+                    const colsArr = Array.isArray(idx?.columns) ? idx.columns.filter(Boolean) : [];
+                    if (colsArr.length === 0)
+                        continue;
+                    const uq = idx.unique ? 'UNIQUE ' : '';
+                    const q = targetDialect === 'postgres' ? (s) => `"${s}"` : (s) => `\`${s}\``;
+                    const cols = colsArr.map(q).join(', ');
+                    try {
+                        await targetDb.execResult(`CREATE ${uq}INDEX IF NOT EXISTS ${q(idx.name)} ON ${q(tableName)} (${cols});`);
+                    }
+                    catch { }
+                }
+            }
+        }
+        else if (mode === 'schema_only') {
+            for (const tableName of insertionOrder) {
+                const norm = normalizedTables.get(tableName);
+                if (!norm)
+                    continue;
+                const targetInfo = await targetDb.getTableInfo(tableName);
+                if (!targetInfo.success || !targetInfo.data || targetInfo.data.columns.length === 0) {
+                    const ddl = (0, dialect_mapper_1.generateCreateTableForDialect)(norm, targetDialect);
+                    const createRes = await targetDb.execResult(ddl);
+                    if (!createRes.success) {
+                        throw new Error(`Failed to create table "${tableName}": ${createRes.error}`);
+                    }
+                }
+            }
+        }
+        else if (mode === 'data_only_replace') {
+            for (const tableName of deletionOrder) {
+                try {
+                    await targetDb.execResult(targetDialect === 'postgres' ? `TRUNCATE TABLE "${tableName}" CASCADE;` : `DELETE FROM \`${tableName}\`;`);
+                }
+                catch { }
+            }
+        }
+        if (mode !== 'schema_only') {
+            for (const p of progressList) {
+                const tableName = p.table;
+                p.status = 'in_progress';
+                const norm = normalizedTables.get(tableName);
+                if (!norm)
+                    continue;
+                const countRes = await sourceDb.getRowCount(tableName);
+                p.totalRows = countRes.data || 0;
+                let offset = 0;
+                let tableRowsCopied = 0;
+                while (offset < p.totalRows || (offset === 0 && p.totalRows === 0)) {
+                    if (p.totalRows === 0)
+                        break;
+                    const rowsRes = await sourceDb.getRows(tableName, { page: Math.floor(offset / batchSize) + 1, limit: batchSize });
+                    const rows = rowsRes.data || [];
+                    if (rows.length === 0)
+                        break;
+                    const targetRows = [];
+                    for (let i = 0; i < rows.length; i++) {
+                        let row = rows[i];
+                        if (maskData) {
+                            row = (0, masking_1.maskRowData)(row, options.maskRules, offset + i + 1);
+                        }
+                        const fields = [];
+                        for (const col of norm.columns) {
+                            const rawVal = row[col.name];
+                            const convertedVal = (0, dialect_mapper_1.convertValueForDialect)(rawVal, col.genericType, targetDialect);
+                            fields.push({ column: col.name, value: convertedVal });
+                        }
+                        targetRows.push(fields);
+                    }
+                    const insertRes = await targetDb.insertRows(tableName, targetRows);
+                    if (!insertRes.success) {
+                        throw new Error(`Failed to insert batch into "${tableName}": ${insertRes.error}`);
+                    }
+                    tableRowsCopied += targetRows.length;
+                    offset += rows.length;
+                }
+                if (targetDialect === 'postgres') {
+                    for (const col of norm.columns) {
+                        if (col.primaryKey && col.autoIncrement) {
+                            try {
+                                await targetDb.all(`SELECT setval(pg_get_serial_sequence('"${tableName}"', '${col.name}'), COALESCE(MAX("${col.name}"), 1)) FROM "${tableName}";`);
+                            }
+                            catch { }
+                        }
+                    }
+                }
+                p.rowsCopied = tableRowsCopied;
+                totalRowsTransferred += tableRowsCopied;
+                p.status = 'completed';
+            }
+        }
+    }
+    catch (err) {
+        return {
+            success: false,
+            dryRun: false,
+            sourceDbId,
+            targetDbId,
+            mode,
+            tablesProcessed: progressList,
+            totalRowsTransferred,
+            executionTimeMs: Date.now() - startTime,
+            error: err.message || String(err),
+            summary: `Sync failed: ${err.message}`,
+        };
+    }
+    finally {
+        try {
+            if (targetDialect === 'sqlite') {
+                await targetDb.execResult('PRAGMA foreign_keys = ON;');
+            }
+            else {
+                try {
+                    await targetDb.execResult('SET CONSTRAINTS ALL IMMEDIATE;');
+                }
+                catch { }
+            }
+        }
+        catch { }
+    }
+    return {
+        success: true,
+        dryRun: false,
+        sourceDbId,
+        targetDbId,
+        mode,
+        tablesProcessed: progressList,
+        totalRowsTransferred,
+        executionTimeMs: Date.now() - startTime,
+        summary: `Successfully synchronized ${progressList.length} tables (${totalRowsTransferred} rows) from "${sourceDbId}" to "${targetDbId}".`,
+    };
+}

package/dist/core/transfer/topological-sort.d.ts

@@ -0,0 +1 @@
+import type {ForeignKeyInfo} from '../../db/types';export interface TableDependency{name:string;foreignKeys:ForeignKeyInfo[];}export declare function sortTablesTopologically(tables:TableDependency[]):string[];export declare function sortTablesForDeletion(tables:TableDependency[]):string[];

package/dist/core/transfer/topological-sort.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortTablesTopologically = sortTablesTopologically;
+exports.sortTablesForDeletion = sortTablesForDeletion;
+function sortTablesTopologically(tables) {
+    const tableNames = new Set(tables.map((t) => t.name));
+    const adj = new Map();
+    const inDegree = new Map();
+    for (const t of tables) {
+        if (!adj.has(t.name))
+            adj.set(t.name, new Set());
+        if (!inDegree.has(t.name))
+            inDegree.set(t.name, 0);
+    }
+    for (const t of tables) {
+        for (const fk of t.foreignKeys) {
+            const parent = fk.table;
+            if (parent && tableNames.has(parent) && parent !== t.name) {
+                if (!adj.get(parent).has(t.name)) {
+                    adj.get(parent).add(t.name);
+                    inDegree.set(t.name, (inDegree.get(t.name) || 0) + 1);
+                }
+            }
+        }
+    }
+    const queue = [];
+    for (const [name, deg] of inDegree.entries()) {
+        if (deg === 0)
+            queue.push(name);
+    }
+    const result = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        result.push(current);
+        const children = adj.get(current) || new Set();
+        for (const child of children) {
+            const newDeg = (inDegree.get(child) || 0) - 1;
+            inDegree.set(child, newDeg);
+            if (newDeg === 0) {
+                queue.push(child);
+            }
+        }
+    }
+    if (result.length < tables.length) {
+        for (const t of tables) {
+            if (!result.includes(t.name)) {
+                result.push(t.name);
+            }
+        }
+    }
+    return result;
+}
+function sortTablesForDeletion(tables) {
+    return [...sortTablesTopologically(tables)].reverse();
+}

package/dist/data/chain.js

@@ -18,7 +18,7 @@ async function getErChainConfig(db, rootTable, scope = 'chain') {
     const tableListRes = await db.listTables();
     const tableNames = (tableListRes.data ?? [])
         .map((t) => t.name)
-        .filter((name) => !name.startsWith('sqlite_') && name !== '_saved_queries');
+        .filter((name) => !name.startsWith('sqlite_'));
     const tables = [];
     for (const name of tableNames) {
         const info = await db.getTableInfo(name);

package/dist/data/engine.js

@@ -114,7 +114,7 @@ class SeedEngine {
         const tableListRes = await db.listTables();
         const tableNames = (tableListRes.data ?? [])
             .map((t) => t.name)
-            .filter((name) => !name.startsWith('sqlite_') && name !== '_saved_queries');
+            .filter((name) => !name.startsWith('sqlite_'));
         const tableInfos = new Map();
         const allTableData = [];
         for (const name of tableNames) {

package/dist/db/database.d.ts

@@ -1 +1 @@
-import type {Logger} from '../utils/logger';import{type ColumnDef,type IndexDef} from '../sql/generator';import type {DatabaseDialect,DbOpenOptions,IDatabase,ReferencingTableInfo,Result,RowFilters,SavedQuery,SchemaInfo,SQLInputValue,TableInfoData,TableListItem,WhereClause} from './types';export * from './types';export * from './filters';export declare class SqliteDatabase implements IDatabase{private db;private logger;readonly path:string;readonly isReadOnly:boolean;readonly dialect:DatabaseDialect;constructor(dbPath:string,logger:Logger,options?:DbOpenOptions);private readonlyBlocked;close():void;private initSchema;private tryRun;private transaction;private toBind;all(sql:string,params?:SQLInputValue[]):Promise<Result<unknown[]>>;run(sql:string,params?:SQLInputValue[]):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;execResult(sql:string):Promise<Result<{changes?:number;}>>;hasMultipleStatements(sql:string):boolean;runWrite(sql:string):Promise<Result<{changes?:number;}>>;listTables():Promise<Result<TableListItem[]>>;getTableInfo(table:string):Promise<Result<TableInfoData>>;getRowCount(table:string,filters?:RowFilters):Promise<Result<number>>;getRows(table:string,opts?:{page?:number;limit?:number;orderBy?:string;orderDir?:'asc'|'desc';filters?:RowFilters;}):Promise<Result<Record<string,unknown>[]>>;getAllRows(table:string):Promise<Result<Record<string,unknown>[]>>;getRow(table:string,where:WhereClause[]):Promise<Result<Record<string,unknown>|null>>;insertRow(table:string,fields:WhereClause[]):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;insertRows(table:string,rows:WhereClause[][]):Promise<Result<{inserted:number;skipped:number;}>>;updateRow(table:string,fields:WhereClause[],where:WhereClause[]):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;updateRows(table:string,rows:{fields:WhereClause[];where:WhereClause[];}[]):Promise<Result<{updated:number;}>>;deleteRow(table:string,where:WhereClause[]):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;deleteRows(table:string,rows:WhereClause[][]):Promise<Result<{deleted:number;}>>;getRowsByPks(table:string,pks:WhereClause[][]):Promise<Result<Record<string,unknown>[]>>;getCreateStatement(table:string):Promise<Result<string|null>>;listSavedQueries():Promise<Result<SavedQuery[]>>;saveQuery(name:string,sql:string):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;deleteSavedQuery(id:string|number):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;getSettings():Promise<Result<Record<string,string>>>;getSchema(table:string):Promise<Result<SchemaInfo>>;getReferencingTables(table:string):Promise<Result<ReferencingTableInfo[]>>;getRowsByFk(table:string,column:string,value:unknown,limit?:number):Promise<Result<{rows:Record<string,unknown>[];total:number;}>>;renameTable(oldName:string,newName:string):Promise<Result<{changes?:number;}>>;addColumn(table:string,col:ColumnDef):Promise<Result<{changes?:number;}>>;modifyColumn(table:string,oldColName:string,newColDef:ColumnDef):Promise<Result<{changes?:number;}>>;renameColumn(table:string,oldName:string,newName:string):Promise<Result<{changes?:number;}>>;dropColumn(table:string,column:string):Promise<Result<{changes?:number;}>>;dropTable(table:string):Promise<Result<{changes?:number;}>>;createIndex(table:string,index:IndexDef):Promise<Result<{changes?:number;}>>;dropIndex(indexName:string):Promise<Result<{changes?:number;}>>;private getTableInfoSync;}
+import type {Logger} from '../utils/logger';import{type ColumnDef,type IndexDef} from '../sql/generator';import type {DatabaseDialect,DbOpenOptions,IDatabase,ReferencingTableInfo,Result,RowFilters,SchemaInfo,SQLInputValue,TableInfoData,TableListItem,WhereClause} from './types';export * from './types';export * from './filters';export declare class SqliteDatabase implements IDatabase{private db;private logger;readonly path:string;readonly isReadOnly:boolean;readonly dialect:DatabaseDialect;constructor(dbPath:string,logger:Logger,options?:DbOpenOptions);private readonlyBlocked;close():void;private tryRun;private transaction;private toBind;all<T=unknown>(sql:string,params?:SQLInputValue[]):Promise<Result<T[]>>;run(sql:string,params?:SQLInputValue[]):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;execResult(sql:string):Promise<Result<{changes?:number;}>>;hasMultipleStatements(sql:string):boolean;runWrite(sql:string):Promise<Result<{changes?:number;}>>;listTables():Promise<Result<TableListItem[]>>;getTableInfo(table:string):Promise<Result<TableInfoData>>;getRowCount(table:string,filters?:RowFilters):Promise<Result<number>>;getRows(table:string,opts?:{page?:number;limit?:number;orderBy?:string;orderDir?:'asc'|'desc';filters?:RowFilters;}):Promise<Result<Record<string,unknown>[]>>;getAllRows(table:string):Promise<Result<Record<string,unknown>[]>>;getRow(table:string,where:WhereClause[]):Promise<Result<Record<string,unknown>|null>>;insertRow(table:string,fields:WhereClause[]):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;insertRows(table:string,rows:WhereClause[][]):Promise<Result<{inserted:number;skipped:number;}>>;updateRow(table:string,fields:WhereClause[],where:WhereClause[]):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;updateRows(table:string,rows:{fields:WhereClause[];where:WhereClause[];}[]):Promise<Result<{updated:number;}>>;deleteRow(table:string,where:WhereClause[]):Promise<Result<{changes:number;lastInsertRowid:number|null;}>>;deleteRows(table:string,rows:WhereClause[][]):Promise<Result<{deleted:number;}>>;getRowsByPks(table:string,pks:WhereClause[][]):Promise<Result<Record<string,unknown>[]>>;getCreateStatement(table:string):Promise<Result<string|null>>;getSettings():Promise<Result<Record<string,string>>>;getSchema(table:string):Promise<Result<SchemaInfo>>;getReferencingTables(table:string):Promise<Result<ReferencingTableInfo[]>>;getRowsByFk(table:string,column:string,value:unknown,limit?:number):Promise<Result<{rows:Record<string,unknown>[];total:number;}>>;renameTable(oldName:string,newName:string):Promise<Result<{changes?:number;}>>;addColumn(table:string,col:ColumnDef):Promise<Result<{changes?:number;}>>;modifyColumn(table:string,oldColName:string,newColDef:ColumnDef):Promise<Result<{changes?:number;}>>;renameColumn(table:string,oldName:string,newName:string):Promise<Result<{changes?:number;}>>;dropColumn(table:string,column:string):Promise<Result<{changes?:number;}>>;dropTable(table:string):Promise<Result<{changes?:number;}>>;createIndex(table:string,index:IndexDef):Promise<Result<{changes?:number;}>>;dropIndex(indexName:string):Promise<Result<{changes?:number;}>>;private getTableInfoSync;}

package/dist/db/database.js

@@ -21,9 +21,8 @@ exports.SqliteDatabase = void 0;
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const generator_1 = require("../sql/generator");
 const common_1 = require("../utils/common");
-const types_1 = require("./types");
 const filters_1 = require("./filters");
-const introspection_1 = require("./introspection");
+const dialect_1 = require("./dialects/sqlite/dialect");
 const migrations_1 = require("./migrations");
 __exportStar(require("./types"), exports);
 __exportStar(require("./filters"), exports);
@@ -44,7 +43,6 @@ class SqliteDatabase {
         }
         else {
             this.db.exec('PRAGMA journal_mode = WAL;');
-            this.initSchema();
         }
         this.logger.info(`Opened SQLite database at ${dbPath}${this.isReadOnly ? ' (read-only)' : ''}`);
     }
@@ -59,16 +57,6 @@ class SqliteDatabase {
             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)(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,
-        ${(0, generator_1.quoteIdentifier)('created_at')} TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-    `);
-    }
     async tryRun(fn) {
         try {
             return { success: true, data: await Promise.resolve(fn()) };
@@ -162,15 +150,15 @@ class SqliteDatabase {
         }
     }
     async listTables() {
-        return this.tryRun(() => (0, introspection_1.listTablesSync)(this.db));
+        return dialect_1.sqliteDialect.introspector.listTables(this.db);
     }
     async getTableInfo(table) {
-        return this.tryRun(() => (0, introspection_1.getTableInfoSync)(this.db, table));
+        return dialect_1.sqliteDialect.introspector.getTableInfo(this.db, table);
     }
     async getRowCount(table, filters) {
         return this.tryRun(() => {
-            const info = this.getTableInfoSync(table);
-            const { where, params } = (0, filters_1.buildFilterClause)(filters, info?.columns.map((c) => c.name) ?? []);
+            const cols = this.db.prepare(`PRAGMA table_info(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            const { where, params } = (0, filters_1.buildFilterClause)(filters, cols.map((c) => c.name));
             const row = this.db
                 .prepare(`SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(table)}${where}`)
                 .get(...params);
@@ -179,9 +167,8 @@ class SqliteDatabase {
     }
     async getRows(table, opts = {}) {
         return this.tryRun(() => {
-            const info = this.getTableInfoSync(table);
-            const cols = info?.columns ?? [];
-            const orderCol = opts.orderBy || info?.primaryKey?.[0] || cols[0]?.name;
+            const cols = this.db.prepare(`PRAGMA table_info(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            const orderCol = opts.orderBy || cols[0]?.name;
             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;
@@ -288,15 +275,6 @@ class SqliteDatabase {
             return row?.sql ?? null;
         });
     }
-    async listSavedQueries() {
-        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)(types_1.INTERNAL_TABLES.savedQueries)} (name, sql) VALUES (?, ?)`, [name, sql]);
-    }
-    async deleteSavedQuery(id) {
-        return this.run(`DELETE FROM ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} WHERE id = ?`, [Number(id)]);
-    }
     async getSettings() {
         return this.tryRun(() => {
             const pragmas = ['journal_mode', 'synchronous', 'foreign_keys', 'page_size', 'encoding', 'auto_vacuum', 'mmap_size', 'temp_store'];
@@ -313,10 +291,10 @@ class SqliteDatabase {
         });
     }
     async getSchema(table) {
-        return this.tryRun(() => (0, introspection_1.getSchemaSync)(this.db, table));
+        return dialect_1.sqliteDialect.introspector.getSchema(this.db, table);
     }
     async getReferencingTables(table) {
-        return this.tryRun(() => (0, introspection_1.getReferencingTablesSync)(this.db, table));
+        return dialect_1.sqliteDialect.introspector.getReferencingTables(this.db, table);
     }
     async getRowsByFk(table, column, value, limit = 50) {
         return this.tryRun(() => {

package/dist/db/dialects/index.d.ts

@@ -0,0 +1 @@
+export * from './types';export * from './sqlite/dialect';export * from './sqlite/types';export * from './sqlite/introspector';export * from './sqlite/ddl';export * from './postgres/dialect';export * from './postgres/types';export * from './postgres/introspector';export * from './postgres/ddl';import type {IDialect} from './types';export interface DialectAdapter<D=unknown>{readonly id:string;readonly name:string;getDialect(schema?:string):IDialect<D>;}export declare class DialectRegistry{private static adapters;static register(adapter:DialectAdapter):void;static get(name:string):DialectAdapter|undefined;static list():string[];}export declare function getDialect(name:'sqlite'|'postgres'|string,schema?:string):IDialect;

package/dist/db/dialects/index.js

@@ -0,0 +1,58 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialectRegistry = void 0;
+exports.getDialect = getDialect;
+__exportStar(require("./types"), exports);
+__exportStar(require("./sqlite/dialect"), exports);
+__exportStar(require("./sqlite/types"), exports);
+__exportStar(require("./sqlite/introspector"), exports);
+__exportStar(require("./sqlite/ddl"), exports);
+__exportStar(require("./postgres/dialect"), exports);
+__exportStar(require("./postgres/types"), exports);
+__exportStar(require("./postgres/introspector"), exports);
+__exportStar(require("./postgres/ddl"), exports);
+const dialect_1 = require("./sqlite/dialect");
+const dialect_2 = require("./postgres/dialect");
+class DialectRegistry {
+    static adapters = new Map();
+    static register(adapter) {
+        this.adapters.set(adapter.id.toLowerCase(), adapter);
+    }
+    static get(name) {
+        return this.adapters.get(name.toLowerCase());
+    }
+    static list() {
+        return Array.from(this.adapters.keys());
+    }
+}
+exports.DialectRegistry = DialectRegistry;
+DialectRegistry.register({
+    id: 'sqlite',
+    name: 'SQLite',
+    getDialect: () => dialect_1.sqliteDialect,
+});
+DialectRegistry.register({
+    id: 'postgres',
+    name: 'PostgreSQL',
+    getDialect: (schema) => (schema && schema !== 'public' ? new dialect_2.PostgresDialect(schema) : dialect_2.postgresDialect),
+});
+function getDialect(name, schema) {
+    const adapter = DialectRegistry.get(name);
+    if (adapter)
+        return adapter.getDialect(schema);
+    return dialect_1.sqliteDialect;
+}

package/dist/db/dialects/postgres/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 class PostgresDdlGenerator implements IDdlGenerator{createTable(table: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;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/postgres/ddl.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresDdlGenerator = void 0;
+const generator_1 = require("../../../sql/generator");
+class PostgresDdlGenerator {
+    createTable(table, columns) {
+        const colDefs = [];
+        const pks = [];
+        for (const c of columns) {
+            let def = `${(0, generator_1.quoteIdentifier)(c.name)} ${c.type}`;
+            if (c.primaryKey)
+                pks.push((0, generator_1.quoteIdentifier)(c.name));
+            if (c.notNull)
+                def += ' NOT NULL';
+            if (c.defaultValue !== undefined && c.defaultValue !== null && c.defaultValue !== '') {
+                def += ` DEFAULT ${c.defaultValue}`;
+            }
+            if (c.unique && !c.primaryKey)
+                def += ' UNIQUE';
+            if (c.foreignKey?.table && c.foreignKey.column) {
+                def += ` REFERENCES ${(0, generator_1.quoteIdentifier)(c.foreignKey.table)} (${(0, generator_1.quoteIdentifier)(c.foreignKey.column)})`;
+            }
+            colDefs.push(`  ${def}`);
+        }
+        if (pks.length) {
+            colDefs.push(`  PRIMARY KEY (${pks.join(', ')})`);
+        }
+        return `CREATE TABLE ${(0, generator_1.quoteIdentifier)(table)} (\n${colDefs.join(',\n')}\n);`;
+    }
+    renameTable(oldName, newName) {
+        return `ALTER TABLE ${(0, generator_1.quoteIdentifier)(oldName)} RENAME TO ${(0, generator_1.quoteIdentifier)(newName)};`;
+    }
+    dropTable(table, options) {
+        const ifExists = options?.ifExists ? 'IF EXISTS ' : '';
+        const cascade = options?.cascade ? ' CASCADE' : '';
+        return `DROP TABLE ${ifExists}${(0, generator_1.quoteIdentifier)(table)}${cascade};`;
+    }
+    truncateTable(table, options) {
+        const restartIdentity = options?.restartIdentity ? ' RESTART IDENTITY' : '';
+        const cascade = options?.cascade ? ' CASCADE' : '';
+        return `TRUNCATE ${(0, generator_1.quoteIdentifier)(table)}${restartIdentity}${cascade};`;
+    }
+    addColumn(table, col) {
+        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)})`;
+        }
+        return sql + ';';
+    }
+    renameColumn(table, oldName, 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) {
+        return `ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} DROP COLUMN ${(0, generator_1.quoteIdentifier)(column)} CASCADE;`;
+    }
+    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)} CASCADE;`;
+    }
+    async modifyColumn(driver, table, oldCol, newCol) {
+        try {
+            const pool = (driver && typeof driver === 'object' && 'pool' in driver)
+                ? driver.pool
+                : driver;
+            const newName = String(newCol.name || oldCol).trim();
+            if (oldCol !== newName) {
+                await pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} RENAME COLUMN ${(0, generator_1.quoteIdentifier)(oldCol)} TO ${(0, generator_1.quoteIdentifier)(newName)};`);
+            }
+            const colToModify = newName;
+            if (newCol.type) {
+                await pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} TYPE ${newCol.type} USING ${(0, generator_1.quoteIdentifier)(colToModify)}::${newCol.type};`);
+            }
+            if (newCol.notNull !== undefined) {
+                const action = newCol.notNull ? 'SET NOT NULL' : 'DROP NOT NULL';
+                await pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} ${action};`);
+            }
+            if (newCol.defaultValue !== undefined) {
+                const action = newCol.defaultValue === null || newCol.defaultValue === '' ? 'DROP DEFAULT' : `SET DEFAULT ${newCol.defaultValue}`;
+                await pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} ${action};`);
+            }
+            if (newCol.unique !== undefined) {
+                const idxName = `idx_${table}_${colToModify}_unique`;
+                if (newCol.unique) {
+                    await 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 pool.query(`DROP INDEX IF EXISTS ${(0, generator_1.quoteIdentifier)(idxName)};`);
+                }
+            }
+            return { success: true, data: { changes: 1 } };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+}
+exports.PostgresDdlGenerator = PostgresDdlGenerator;

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

@@ -0,0 +1 @@
+import type {DialectCapabilities,IDialect} from '../types';import{PostgresDdlGenerator} from './ddl';import{PostgresIntrospector} from './introspector';export declare class PostgresDialect implements IDialect{readonly name:"postgres";readonly capabilities:DialectCapabilities;readonly introspector:PostgresIntrospector;readonly ddl:PostgresDdlGenerator;constructor(schema?:string);quoteIdentifier(identifier:string):string;mapType(type:string):import("./types").MappedType;getDesignerTypes():readonly string[];}export declare const postgresDialect:PostgresDialect;