admindb 2.4.0 → 2.5.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 Muhammad Bin Khalid
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2025 Muhammad Bin Khalid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/dist/app.js

@@ -10,14 +10,13 @@ const express_handlebars_1 = require("express-handlebars");
 const database_1 = require("./db/database");
 const postgres_1 = require("./db/postgres");
 const logger_1 = require("./utils/logger");
-const pages_1 = require("./routes/pages");
-const index_1 = require("./routes/api/index");
-const databases_1 = require("./routes/databases");
+const index_1 = require("./modules/index");
 const args_1 = require("./cli/args");
 const common_1 = require("./utils/common");
 const icons_1 = require("./utils/icons");
 const serverless_1 = require("./serverless");
 const auth_1 = require("./auth");
+const index_2 = require("./db/dialects/index");
 const APP_VERSION = (0, args_1.getPackageVersion)();
 function createRouter(options = {}) {
     const isServerless = options.serverless !== undefined ? options.serverless : (0, serverless_1.isServerlessEnvironment)();
@@ -60,10 +59,15 @@ function createRouter(options = {}) {
         else {
             singleDb = new database_1.SqliteDatabase(options.dbPath ?? 'admindb.db', logger, { readonly: globalReadonly });
         }
-        if (!defaultDbId) {
+        if (!defaultDbId && singleDb) {
             defaultDbId = singleDb.dialect === 'postgres' ? 'PostgreSQL' : (node_path_1.default.basename(singleDb.path) || 'SQLite');
         }
     }
+    let singleDialect;
+    if (singleDb) {
+        const pgSchema = singleDb.schema || 'public';
+        singleDialect = (0, index_2.getDialect)(singleDb.dialect, singleDb.dialect === 'postgres' ? pgSchema : undefined);
+    }
     const app = (0, express_1.default)();
     app.disable('x-powered-by');
     app.use(express_1.default.static(node_path_1.default.join(__dirname, 'public')));
@@ -88,14 +92,28 @@ function createRouter(options = {}) {
             res.locals.isDefaultPassword = authConfig.isDefaultPassword;
             res.locals.icons = icons_1.ICONS;
             res.locals.tables = [];
-            res.locals.internalTables = [];
             next();
         }
         catch (err) {
             next(err);
         }
     });
-    const getDb = (req) => {
+    if (manager) {
+        (0, index_1.registerDatabasesRoutes)(app, {
+            manager,
+            logger,
+            basePath,
+            readonly: globalReadonly,
+            allowBrowse: isServerless ? false : options.allowBrowse,
+            browseRoot: options.browseRoot,
+        });
+    }
+    else {
+        app.get('/', (_req, res) => {
+            res.redirect(302, `${basePath}/home/${encodeURIComponent(defaultDbId)}`);
+        });
+    }
+    const getContext = (req) => {
         if (manager) {
             const dbId = String(req.params.db || req.params.dbId || req.params.id || '');
             if (!manager.has(dbId)) {
@@ -111,27 +129,20 @@ function createRouter(options = {}) {
                 }
             }
             const effectiveRo = globalReadonly ? true : manager.isDbReadOnly(dbId);
-            return manager.open(dbId, effectiveRo);
+            return manager.getContext(dbId, effectiveRo);
         }
-        return singleDb;
-    };
-    if (manager) {
-        (0, databases_1.registerDatabasesRoutes)(app, {
-            manager,
+        return {
+            id: defaultDbId,
+            name: defaultDbId,
+            path: singleDb.path,
+            db: singleDb,
+            dialect: singleDialect,
+            capabilities: singleDialect.capabilities,
+            isReadOnly: singleDb.isReadOnly,
             logger,
-            basePath,
-            readonly: globalReadonly,
-            allowBrowse: isServerless ? false : options.allowBrowse,
-            browseRoot: options.browseRoot,
-        });
-    }
-    else {
-        app.get('/', (_req, res) => {
-            res.redirect(302, `${basePath}/home/${encodeURIComponent(defaultDbId)}`);
-        });
-    }
-    (0, pages_1.registerPages)(app, { getDb, logger });
-    (0, index_1.registerApi)(app, { getDb, logger });
+        };
+    };
+    (0, index_1.registerModules)(app, { getContext, logger });
     addErrorHandlers(app, logger);
     return app;
 }

package/dist/core/context.d.ts

@@ -0,0 +1 @@
+import type {Logger} from '../utils/logger';import type {IDatabase} from '../db/types';import type {IDialect,DialectCapabilities} from '../db/dialects/types';export interface DatabaseContext{readonly id:string;readonly name:string;readonly path:string;readonly db:IDatabase;readonly dialect:IDialect;readonly capabilities:DialectCapabilities;readonly isReadOnly:boolean;readonly logger:Logger;}

package/dist/core/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/errors.d.ts

@@ -0,0 +1 @@
+export declare class AppError extends Error{readonly status:number;readonly details?:Record<string,unknown>;constructor(message:string,status?:number,details?:Record<string,unknown>);}export declare class NotFoundError extends AppError{constructor(message?:string,details?:Record<string,unknown>);}export declare class BadRequestError extends AppError{constructor(message:string,details?:Record<string,unknown>);}export declare class ForbiddenError extends AppError{constructor(message?:string,details?:Record<string,unknown>);}export declare class ConflictError extends AppError{constructor(message:string,details?:Record<string,unknown>);}

package/dist/core/errors.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = exports.ForbiddenError = exports.BadRequestError = exports.NotFoundError = exports.AppError = void 0;
+class AppError extends Error {
+    status;
+    details;
+    constructor(message, status = 500, details) {
+        super(message);
+        this.name = this.constructor.name;
+        this.status = status;
+        this.details = details;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.AppError = AppError;
+class NotFoundError extends AppError {
+    constructor(message = 'Resource not found.', details) {
+        super(message, 404, details);
+    }
+}
+exports.NotFoundError = NotFoundError;
+class BadRequestError extends AppError {
+    constructor(message, details) {
+        super(message, 400, details);
+    }
+}
+exports.BadRequestError = BadRequestError;
+class ForbiddenError extends AppError {
+    constructor(message = 'Database is open in read-only mode — write operations are disabled.', details) {
+        super(message, 403, details);
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class ConflictError extends AppError {
+    constructor(message, details) {
+        super(message, 409, details);
+    }
+}
+exports.ConflictError = ConflictError;

package/dist/core/index.d.ts

@@ -0,0 +1 @@
+export * from './result';export * from './errors';export * from './context';export * from './router';

package/dist/core/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./result"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./router"), exports);

package/dist/core/result.d.ts

@@ -0,0 +1 @@
+export type SQLInputValue=null|number|bigint|string|boolean|Uint8Array|Buffer|Date;export interface Result<T=unknown>{success:boolean;data?:T;error?:string;}export interface MutationResult{changes?:number;lastInsertRowid?:number|null;}export declare function okResult<T>(data?:T):Result<T>;export declare function errResult<T=never>(error:string):Result<T>;

package/dist/core/result.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.okResult = okResult;
+exports.errResult = errResult;
+function okResult(data) {
+    return { success: true, ...(data !== undefined ? { data } : {}) };
+}
+function errResult(error) {
+    return { success: false, error };
+}

package/dist/core/router.d.ts

@@ -0,0 +1 @@
+import type {Request,Response,NextFunction} from 'express';import type {DatabaseContext} from './context';import type {Logger} from '../utils/logger';export interface RouteContext{getContext:(req:Request)=>DatabaseContext;logger:Logger;}export declare const ok:(res:Response,data:unknown,status?:number)=>Response;export declare const fail:(res:Response,error:string,status?:number,details?:Record<string,unknown>|null)=>Response;export declare const notFound:(res:Response,message:string)=>void;export declare const wrap:(fn:(req:Request,res:Response,next?:NextFunction)=>unknown)=>(req:Request,res:Response,next?:NextFunction)=>Promise<void>;export declare function initPageLocals(res:Response,dbOrCtx:{dialect:string|{name:string;};path:string;isReadOnly:boolean;},dbId:string,allNames:string[]):{tables:string[];};

package/dist/core/router.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrap = exports.notFound = exports.fail = exports.ok = void 0;
+exports.initPageLocals = initPageLocals;
+const common_1 = require("../utils/common");
+const ok = (res, data, status = 200) => res.status(status).json({ success: true, data });
+exports.ok = ok;
+const fail = (res, error, status = 400, details) => res.status(status).json({ success: false, error, ...(details ? { details } : {}) });
+exports.fail = fail;
+const notFound = (res, message) => {
+    res.status(404).render('pages/error', { title: 'Not found', status: 404, error: message });
+};
+exports.notFound = notFound;
+const wrap = (fn) => async (req, res, next) => {
+    try {
+        await fn(req, res, next);
+    }
+    catch (err) {
+        (0, exports.fail)(res, (0, common_1.errorMessage)(err), 500);
+    }
+};
+exports.wrap = wrap;
+function initPageLocals(res, dbOrCtx, dbId, allNames) {
+    const dialectName = typeof dbOrCtx.dialect === 'string' ? dbOrCtx.dialect : dbOrCtx.dialect.name;
+    const isPostgres = dialectName === 'postgres';
+    const isSqlite = dialectName === 'sqlite';
+    res.locals.dbId = dbId;
+    res.locals.dbPath = dbOrCtx.path;
+    res.locals.tables = allNames;
+    res.locals.dialect = dialectName;
+    res.locals.isPostgres = isPostgres;
+    res.locals.isSqlite = isSqlite;
+    res.locals.dialectName = isPostgres ? 'PostgreSQL' : 'SQLite';
+    res.locals.readonly = dbOrCtx.isReadOnly;
+    res.locals.databasesMode = false;
+    return { tables: allNames };
+}

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;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postgresDialect = exports.PostgresDialect = 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 PostgresDialect {
+    name = 'postgres';
+    capabilities = types_1.POSTGRES_CAPABILITIES;
+    introspector;
+    ddl = new ddl_1.PostgresDdlGenerator();
+    constructor(schema = 'public') {
+        this.introspector = new introspector_1.PostgresIntrospector(schema);
+    }
+    quoteIdentifier(identifier) {
+        return (0, generator_1.quoteIdentifier)(identifier);
+    }
+    mapType(type) {
+        return (0, types_2.mapPostgresColumnType)(type);
+    }
+    getDesignerTypes() {
+        return types_2.POSTGRES_DESIGNER_TYPES;
+    }
+}
+exports.PostgresDialect = PostgresDialect;
+exports.postgresDialect = new PostgresDialect();

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

@@ -0,0 +1 @@
+import type {ISchemaIntrospector} from '../types';import type {ReferencingTableInfo,Result,SchemaInfo,TableInfoData,TableListItem} from '../../types';export declare class PostgresIntrospector implements ISchemaIntrospector{private schema;constructor(schema?:string);private getPool;listTables(driver:unknown):Promise<Result<TableListItem[]>>;getColumnCountMap(driver:unknown):Promise<Result<Record<string,number>>>;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>>;}