admindb 2.4.1 → 2.6.0

package/dist/db/postgres.js

@@ -4,8 +4,8 @@ exports.PostgresDatabase = void 0;
 const pg_1 = require("pg");
 const generator_1 = require("../sql/generator");
 const common_1 = require("../utils/common");
-const types_1 = require("./types");
 const filters_1 = require("./filters");
+const index_1 = require("./dialects/index");
 class PostgresDatabase {
     pool;
     logger;
@@ -13,6 +13,7 @@ class PostgresDatabase {
     isReadOnly;
     dialect = 'postgres';
     schema;
+    dialectInstance;
     constructor(connection, logger, options = {}) {
         this.logger = logger;
         const opts = typeof connection === 'string'
@@ -20,6 +21,7 @@ class PostgresDatabase {
             : { ...connection, ...options };
         this.isReadOnly = Boolean(opts.readonly);
         this.schema = opts.schema || 'public';
+        this.dialectInstance = (0, index_1.getDialect)('postgres', this.schema);
         let sslConfig = opts.ssl;
         if (opts.connectionString) {
             try {
@@ -62,11 +64,6 @@ class PostgresDatabase {
         this.pool.on('error', (err) => {
             this.logger.error(`Unexpected PostgreSQL client error: ${(0, common_1.errorMessage)(err)}`);
         });
-        if (!this.isReadOnly) {
-            this.initSchema().catch((err) => {
-                this.logger.warn(`Failed to initialize Postgres schema: ${(0, common_1.errorMessage)(err)}`);
-            });
-        }
         this.logger.info(`Initialized PostgreSQL pool for ${this.path}${this.isReadOnly ? ' (read-only)' : ''}`);
     }
     readonlyBlocked() {
@@ -113,16 +110,6 @@ class PostgresDatabase {
             client.release();
         }
     }
-    async initSchema() {
-        await this.pool.query(`
-      CREATE TABLE IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} (
-        id SERIAL PRIMARY KEY,
-        name VARCHAR(255) NOT NULL UNIQUE,
-        sql TEXT NOT NULL,
-        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-      );
-    `);
-    }
     hasMultipleStatements(sql) {
         const s = String(sql ?? '').trim();
         if (!s)
@@ -173,121 +160,10 @@ class PostgresDatabase {
         return this.execResult(sql);
     }
     async listTables() {
-        return this.tryRun(async () => {
-            const res = await this.pool.query(`SELECT table_name AS name
-         FROM information_schema.tables
-         WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-         ORDER BY table_name;`, [this.schema]);
-            return res.rows.map((r) => ({ name: r.name }));
-        });
+        return this.dialectInstance.introspector.listTables(this.pool);
     }
     async getTableInfo(table) {
-        return this.tryRun(async () => {
-            const [colRes, pkRes, fkRes, idxRes] = await Promise.all([
-                this.pool.query(`SELECT
-             ordinal_position AS cid,
-             column_name AS name,
-             data_type AS type,
-             udt_name,
-             CASE WHEN is_nullable = 'NO' THEN 1 ELSE 0 END AS notnull,
-             column_default AS dflt_value
-           FROM information_schema.columns
-           WHERE table_schema = $1 AND table_name = $2
-           ORDER BY ordinal_position;`, [this.schema, table]),
-                this.pool.query(`SELECT kcu.column_name
-           FROM information_schema.table_constraints tc
-           JOIN information_schema.key_column_usage kcu
-             ON tc.constraint_name = kcu.constraint_name
-             AND tc.table_schema = kcu.table_schema
-           WHERE tc.constraint_type = 'PRIMARY KEY'
-             AND tc.table_schema = $1
-             AND tc.table_name = $2
-           ORDER BY kcu.ordinal_position;`, [this.schema, table]),
-                this.pool.query(`SELECT
-             row_number() OVER () AS id,
-             kcu.position_in_unique_constraint AS seq,
-             ccu.table_name AS table,
-             kcu.column_name AS "from",
-             ccu.column_name AS "to",
-             rc.update_rule AS on_update,
-             rc.delete_rule AS on_delete
-           FROM information_schema.table_constraints AS tc
-           JOIN information_schema.key_column_usage AS kcu
-             ON tc.constraint_name = kcu.constraint_name
-             AND tc.table_schema = kcu.table_schema
-           JOIN information_schema.constraint_column_usage AS ccu
-             ON ccu.constraint_name = tc.constraint_name
-             AND ccu.table_schema = tc.table_schema
-           JOIN information_schema.referential_constraints AS rc
-             ON rc.constraint_name = tc.constraint_name
-             AND rc.constraint_schema = tc.table_schema
-           WHERE tc.constraint_type = 'FOREIGN KEY'
-             AND tc.table_schema = $1
-             AND tc.table_name = $2;`, [this.schema, table]),
-                this.pool.query(`SELECT
-             i.relname AS name,
-             ix.indisunique AS unique,
-             pg_get_indexdef(ix.indexrelid) AS sql,
-             ARRAY(
-               SELECT pg_get_indexdef(ix.indexrelid, k + 1, true)
-               FROM generate_subscripts(ix.indkey, 1) as k
-               ORDER BY k
-             ) AS columns
-           FROM pg_index ix
-           JOIN pg_class t ON t.oid = ix.indrelid
-           JOIN pg_class i ON i.oid = ix.indexrelid
-           JOIN pg_namespace n ON n.oid = t.relnamespace
-           WHERE n.nspname = $1 AND t.relname = $2;`, [this.schema, table]),
-            ]);
-            const primaryKey = pkRes.rows.map((r) => r.column_name);
-            const columns = colRes.rows.map((c) => {
-                const isPk = primaryKey.includes(c.name);
-                const displayType = c.type === 'USER-DEFINED' ? c.udt_name : c.type;
-                return {
-                    cid: c.cid,
-                    name: c.name,
-                    type: displayType.toUpperCase(),
-                    notnull: c.notnull,
-                    dflt_value: c.dflt_value,
-                    pk: isPk ? primaryKey.indexOf(c.name) + 1 : 0,
-                };
-            });
-            const indexes = idxRes.rows.map((ix) => ({
-                name: ix.name,
-                unique: Boolean(ix.unique),
-                partial: 0,
-                origin: 'c',
-                columns: Array.isArray(ix.columns) ? ix.columns : [],
-                sql: ix.sql,
-            }));
-            const colDefs = columns.map((c) => {
-                let def = `  ${(0, generator_1.quoteIdentifier)(c.name)} ${c.type}`;
-                if (c.notnull)
-                    def += ' NOT NULL';
-                if (c.dflt_value)
-                    def += ` DEFAULT ${c.dflt_value}`;
-                return def;
-            });
-            if (primaryKey.length) {
-                colDefs.push(`  PRIMARY KEY (${primaryKey.map(generator_1.quoteIdentifier).join(', ')})`);
-            }
-            return {
-                table,
-                columns,
-                foreignKeys: fkRes.rows.map((f) => ({
-                    id: Number(f.id),
-                    seq: Number(f.seq ?? 1),
-                    table: f.table,
-                    from: f.from,
-                    to: f.to,
-                    on_update: f.on_update,
-                    on_delete: f.on_delete,
-                })),
-                primaryKey,
-                indexes,
-                sql: `CREATE TABLE ${(0, generator_1.quoteIdentifier)(table)} (\n${colDefs.join(',\n')}\n);`,
-            };
-        });
+        return this.dialectInstance.introspector.getTableInfo(this.pool, table);
     }
     async getRowCount(table, filters) {
         return this.tryRun(async () => {
@@ -450,24 +326,6 @@ class PostgresDatabase {
             return { success: false, error: info.error };
         return { success: true, data: info.data.sql };
     }
-    async listSavedQueries() {
-        return this.tryRun(async () => {
-            const res = await this.pool.query(`SELECT id, name, sql, created_at FROM ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} ORDER BY name`);
-            return res.rows;
-        });
-    }
-    async saveQuery(name, sql) {
-        return this.tryRun(async () => {
-            const res = await this.pool.query(`INSERT INTO ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} (name, sql) VALUES ($1, $2) RETURNING id`, [name, sql]);
-            return { changes: res.rowCount ?? 1, lastInsertRowid: Number(res.rows[0]?.id ?? null) };
-        });
-    }
-    async deleteSavedQuery(id) {
-        return this.tryRun(async () => {
-            const res = await this.pool.query(`DELETE FROM ${(0, generator_1.quoteIdentifier)(types_1.INTERNAL_TABLES.savedQueries)} WHERE id = $1`, [Number(id)]);
-            return { changes: res.rowCount ?? 0, lastInsertRowid: null };
-        });
-    }
     async getSettings() {
         return this.tryRun(async () => {
             const keys = ['server_version', 'max_connections', 'port', 'timezone', 'shared_buffers', 'work_mem'];
@@ -488,100 +346,16 @@ class PostgresDatabase {
         });
     }
     async getSchema(table) {
-        return this.tryRun(async () => {
-            const infoR = await this.getTableInfo(table);
-            if (!infoR.success || !infoR.data)
-                throw new Error(infoR.error || `Table ${table} not found.`);
-            const { columns, foreignKeys, indexes, primaryKey } = infoR.data;
-            const refRes = await this.pool.query(`SELECT
-           tc.table_name AS table,
-           kcu.column_name AS "from",
-           ccu.column_name AS "to"
-         FROM information_schema.table_constraints AS tc
-         JOIN information_schema.key_column_usage AS kcu
-           ON tc.constraint_name = kcu.constraint_name
-           AND tc.table_schema = kcu.table_schema
-         JOIN information_schema.constraint_column_usage AS ccu
-           ON ccu.constraint_name = tc.constraint_name
-           AND ccu.table_schema = tc.table_schema
-         WHERE tc.constraint_type = 'FOREIGN KEY'
-           AND tc.table_schema = $1
-           AND ccu.table_name = $2;`, [this.schema, table]);
-            const references = refRes.rows;
-            const columnDetails = columns.map((col) => {
-                const isPk = primaryKey.includes(col.name);
-                const fk = foreignKeys.find((f) => f.from === col.name) ?? null;
-                const matchingIndexes = indexes.filter((i) => i.columns.includes(col.name));
-                const unique = matchingIndexes.some((i) => i.unique && i.columns.length === 1 && i.columns[0] === col.name);
-                const indexed = matchingIndexes.length > 0;
-                const referencedBy = references
-                    .filter((r) => r.to === col.name)
-                    .map((r) => ({ table: r.table, from: r.from }));
-                const dropBlockers = [];
-                if (isPk && primaryKey.length === 1)
-                    dropBlockers.push('Primary key');
-                if (referencedBy.length > 0) {
-                    dropBlockers.push(`Referenced by ${referencedBy.map((r) => `${r.table}.${r.from}`).join(', ')}`);
-                }
-                return {
-                    ...col,
-                    unique,
-                    indexed,
-                    referencedBy,
-                    fk,
-                    canDrop: dropBlockers.length === 0,
-                    dropBlockers,
-                };
-            });
-            return {
-                table,
-                columns: columnDetails,
-                foreignKeys,
-                indexes,
-                references,
-            };
-        });
+        return this.dialectInstance.introspector.getSchema(this.pool, table);
     }
     async getReferencingTables(table) {
-        return this.tryRun(async () => {
-            const refRes = await this.pool.query(`SELECT
-           tc.table_name AS table,
-           kcu.column_name AS "from",
-           ccu.column_name AS "to"
-         FROM information_schema.table_constraints AS tc
-         JOIN information_schema.key_column_usage AS kcu
-           ON tc.constraint_name = kcu.constraint_name
-           AND tc.table_schema = kcu.table_schema
-         JOIN information_schema.constraint_column_usage AS ccu
-           ON ccu.constraint_name = tc.constraint_name
-           AND ccu.table_schema = tc.table_schema
-         WHERE tc.constraint_type = 'FOREIGN KEY'
-           AND tc.table_schema = $1
-           AND ccu.table_name = $2;`, [this.schema, table]);
-            const byTable = new Map();
-            for (const r of refRes.rows) {
-                if (!byTable.has(r.table))
-                    byTable.set(r.table, []);
-                byTable.get(r.table).push({ from: r.from, to: r.to });
-            }
-            const results = [];
-            for (const [tbl, refs] of byTable.entries()) {
-                try {
-                    const countRes = await this.pool.query(`SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(tbl)} WHERE ${refs.map((r) => `${(0, generator_1.quoteIdentifier)(r.from)} IS NOT NULL`).join(' OR ')}`);
-                    results.push({ table: tbl, refs, refCount: Number(countRes.rows[0]?.c ?? 0) });
-                }
-                catch {
-                    results.push({ table: tbl, refs, refCount: 0 });
-                }
-            }
-            return results;
-        });
+        return this.dialectInstance.introspector.getReferencingTables(this.pool, table);
     }
     async renameTable(oldName, newName) {
         if (this.isReadOnly)
             return this.readonlyBlocked();
         return this.tryRun(async () => {
-            await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(oldName)} RENAME TO ${(0, generator_1.quoteIdentifier)(newName)};`);
+            await this.pool.query(this.dialectInstance.ddl.renameTable(oldName, newName));
             return { changes: 1 };
         });
     }
@@ -589,19 +363,13 @@ class PostgresDatabase {
         if (this.isReadOnly)
             return this.readonlyBlocked();
         return this.tryRun(async () => {
-            let sql = `ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ADD COLUMN ${(0, generator_1.quoteIdentifier)(col.name)} ${col.type}`;
-            if (col.notNull)
-                sql += ' NOT NULL';
-            if (col.defaultValue !== undefined && col.defaultValue !== null && col.defaultValue !== '') {
-                sql += ` DEFAULT ${col.defaultValue}`;
-            }
-            if (col.foreignKey) {
-                sql += ` REFERENCES ${(0, generator_1.quoteIdentifier)(col.foreignKey.table)} (${(0, generator_1.quoteIdentifier)(col.foreignKey.column)})`;
-            }
-            await this.pool.query(sql);
+            await this.pool.query(this.dialectInstance.ddl.addColumn(table, col));
             if (col.unique) {
-                const idxName = `idx_${table}_${col.name}_unique`;
-                await this.pool.query(`CREATE UNIQUE INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(idxName)} ON ${(0, generator_1.quoteIdentifier)(table)} (${(0, generator_1.quoteIdentifier)(col.name)});`);
+                await this.pool.query(this.dialectInstance.ddl.createIndex(table, {
+                    name: `idx_${table}_${col.name}_unique`,
+                    columns: [col.name],
+                    unique: true,
+                }));
             }
             return { changes: 1 };
         });
@@ -609,42 +377,13 @@ class PostgresDatabase {
     async modifyColumn(table, oldColName, newColDef) {
         if (this.isReadOnly)
             return this.readonlyBlocked();
-        return this.tryRun(async () => {
-            const newName = String(newColDef.name || oldColName).trim();
-            if (oldColName !== newName) {
-                await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} RENAME COLUMN ${(0, generator_1.quoteIdentifier)(oldColName)} TO ${(0, generator_1.quoteIdentifier)(newName)};`);
-            }
-            const colToModify = newName;
-            if (newColDef.type) {
-                await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} TYPE ${newColDef.type} USING ${(0, generator_1.quoteIdentifier)(colToModify)}::${newColDef.type};`);
-            }
-            if (newColDef.notNull !== undefined) {
-                const action = newColDef.notNull ? 'SET NOT NULL' : 'DROP NOT NULL';
-                await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} ${action};`);
-            }
-            if (newColDef.defaultValue !== undefined) {
-                const action = newColDef.defaultValue === null || newColDef.defaultValue === ''
-                    ? 'DROP DEFAULT'
-                    : `SET DEFAULT ${newColDef.defaultValue}`;
-                await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} ALTER COLUMN ${(0, generator_1.quoteIdentifier)(colToModify)} ${action};`);
-            }
-            if (newColDef.unique !== undefined) {
-                const idxName = `idx_${table}_${colToModify}_unique`;
-                if (newColDef.unique) {
-                    await this.pool.query(`CREATE UNIQUE INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(idxName)} ON ${(0, generator_1.quoteIdentifier)(table)} (${(0, generator_1.quoteIdentifier)(colToModify)});`);
-                }
-                else {
-                    await this.pool.query(`DROP INDEX IF EXISTS ${(0, generator_1.quoteIdentifier)(idxName)};`);
-                }
-            }
-            return { changes: 1 };
-        });
+        return this.dialectInstance.ddl.modifyColumn(this.pool, table, oldColName, newColDef);
     }
     async renameColumn(table, oldName, newName) {
         if (this.isReadOnly)
             return this.readonlyBlocked();
         return this.tryRun(async () => {
-            await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} RENAME COLUMN ${(0, generator_1.quoteIdentifier)(oldName)} TO ${(0, generator_1.quoteIdentifier)(newName)};`);
+            await this.pool.query(this.dialectInstance.ddl.renameColumn(table, oldName, newName));
             return { changes: 1 };
         });
     }
@@ -652,7 +391,7 @@ class PostgresDatabase {
         if (this.isReadOnly)
             return this.readonlyBlocked();
         return this.tryRun(async () => {
-            await this.pool.query(`ALTER TABLE ${(0, generator_1.quoteIdentifier)(table)} DROP COLUMN ${(0, generator_1.quoteIdentifier)(column)} CASCADE;`);
+            await this.pool.query(this.dialectInstance.ddl.dropColumn(table, column));
             return { changes: 1 };
         });
     }
@@ -660,7 +399,7 @@ class PostgresDatabase {
         if (this.isReadOnly)
             return this.readonlyBlocked();
         return this.tryRun(async () => {
-            await this.pool.query(`DROP TABLE ${(0, generator_1.quoteIdentifier)(table)} CASCADE;`);
+            await this.pool.query(this.dialectInstance.ddl.dropTable(table, { cascade: true }));
             return { changes: 1 };
         });
     }
@@ -668,10 +407,7 @@ class PostgresDatabase {
         if (this.isReadOnly)
             return this.readonlyBlocked();
         return this.tryRun(async () => {
-            const unique = index.unique ? 'UNIQUE ' : '';
-            const cols = index.columns.map(generator_1.quoteIdentifier).join(', ');
-            const name = index.name || `idx_${table}_${index.columns.join('_')}`;
-            await this.pool.query(`CREATE ${unique}INDEX IF NOT EXISTS ${(0, generator_1.quoteIdentifier)(name)} ON ${(0, generator_1.quoteIdentifier)(table)} (${cols});`);
+            await this.pool.query(this.dialectInstance.ddl.createIndex(table, index));
             return { changes: 1 };
         });
     }
@@ -679,7 +415,7 @@ class PostgresDatabase {
         if (this.isReadOnly)
             return this.readonlyBlocked();
         return this.tryRun(async () => {
-            await this.pool.query(`DROP INDEX IF EXISTS ${(0, generator_1.quoteIdentifier)(indexName)} CASCADE;`);
+            await this.pool.query(this.dialectInstance.ddl.dropIndex(indexName));
             return { changes: 1 };
         });
     }

package/dist/db/types.d.ts

@@ -1 +1 @@
-import type {FilterValue} from '../utils/common';import type {ColumnDef,IndexDef} from '../sql/generator';export type {FilterCondition,FilterValue} from '../utils/common';export type DatabaseDialect='sqlite'|'postgres';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 interface TableListItem{name:string;}export interface ColumnInfo{cid:number;name:string;type:string;notnull:number;dflt_value:string|null;pk:number;}export interface ForeignKeyInfo{id:number;seq:number;table:string; from :string;to:string|null;on_update:string;on_delete:string;}export interface TableInfoData{table:string;columns:ColumnInfo[];foreignKeys:ForeignKeyInfo[];primaryKey:string[];indexes:IndexInfo[];sql:string|null;}export interface SavedQuery{id:number;name:string;sql:string;created_at:string;}export interface WhereClause{column:string;value:unknown;}export interface IndexInfo{name:string;unique:boolean;partial:number;origin:string;columns:string[];sql?:string|null;}export interface RowFilters{[column:string]:FilterValue;}export interface ColumnDetail extends ColumnInfo{unique:boolean;indexed:boolean;referencedBy:{table:string; from :string;}[];fk:ForeignKeyInfo|null;canDrop:boolean;dropBlockers:string[];}export interface SchemaInfo{table:string;columns:ColumnDetail[];foreignKeys:ForeignKeyInfo[];indexes:IndexInfo[];references:{table:string; from :string;to:string;}[];}export interface ReferencingTableInfo{table:string;refs:{ from :string;to:string;}[];refCount:number;}export interface DbOpenOptions{readonly ?:boolean;}export interface PostgresOptions extends DbOpenOptions{connectionString?:string;host?:string;port?:number;database?:string;user?:string;password?:string;ssl?:boolean|object;max?:number;schema?:string;}export interface QueryOptions{page?:number;limit?:number;orderBy?:string;orderDir?:'asc'|'desc';filters?:RowFilters;}export declare const INTERNAL_TABLES:{readonly savedQueries:"_saved_queries";};export interface IDatabase{readonly path:string;readonly isReadOnly:boolean;readonly dialect:DatabaseDialect;close():Promise<void>|void;all(sql:string,params?:SQLInputValue[]):Promise<Result<unknown[]>>;run(sql:string,params?:SQLInputValue[]):Promise<Result<MutationResult>>;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?:QueryOptions):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<MutationResult>>;insertRows(table:string,rows:WhereClause[][]):Promise<Result<{inserted:number;skipped:number;}>>;updateRow(table:string,fields:WhereClause[],where:WhereClause[]):Promise<Result<MutationResult>>;updateRows(table:string,rows:{fields:WhereClause[];where:WhereClause[];}[]):Promise<Result<{updated:number;}>>;deleteRow(table:string,where:WhereClause[]):Promise<Result<MutationResult>>;deleteRows(table:string,rows:WhereClause[][]):Promise<Result<{deleted:number;}>>;getRowsByPks(table:string,pks:WhereClause[][]):Promise<Result<Record<string,unknown>[]>>;getRowsByFk(table:string,column:string,value:unknown,limit?:number):Promise<Result<{rows:Record<string,unknown>[];total:number;}>>;getCreateStatement(table:string):Promise<Result<string|null>>;listSavedQueries():Promise<Result<SavedQuery[]>>;saveQuery(name:string,sql:string):Promise<Result<MutationResult>>;deleteSavedQuery(id:string|number):Promise<Result<MutationResult>>;getSettings():Promise<Result<Record<string,string>>>;getSchema(table:string):Promise<Result<SchemaInfo>>;getReferencingTables(table:string):Promise<Result<ReferencingTableInfo[]>>;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;}>>;}
+import type {FilterValue} from '../utils/common';import type {ColumnDef,IndexDef} from '../sql/generator';import type {IDatabaseDriver} from './dialects/types';export type {FilterCondition,FilterValue} from '../utils/common';export type {IDatabaseDriver} from './dialects/types';export type DatabaseDialect='sqlite'|'postgres';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 interface TableListItem{name:string;}export interface ColumnInfo{cid:number;name:string;type:string;notnull:number;dflt_value:string|null;pk:number;}export interface ForeignKeyInfo{id:number;seq:number;table:string; from :string;to:string|null;on_update:string;on_delete:string;}export interface TableInfoData{table:string;columns:ColumnInfo[];foreignKeys:ForeignKeyInfo[];primaryKey:string[];indexes:IndexInfo[];sql:string|null;}export interface WhereClause{column:string;value:unknown;}export interface IndexInfo{name:string;unique:boolean;partial:number;origin:string;columns:string[];sql?:string|null;}export interface RowFilters{[column:string]:FilterValue;}export interface ColumnDetail extends ColumnInfo{unique:boolean;indexed:boolean;referencedBy:{table:string; from :string;}[];fk:ForeignKeyInfo|null;canDrop:boolean;dropBlockers:string[];}export interface SchemaInfo{table:string;columns:ColumnDetail[];foreignKeys:ForeignKeyInfo[];indexes:IndexInfo[];references:{table:string; from :string;to:string;}[];}export interface ReferencingTableInfo{table:string;refs:{ from :string;to:string;}[];refCount:number;}export interface DbOpenOptions{readonly ?:boolean;}export interface PostgresOptions extends DbOpenOptions{connectionString?:string;host?:string;port?:number;database?:string;user?:string;password?:string;ssl?:boolean|object;max?:number;schema?:string;}export interface QueryOptions{page?:number;limit?:number;orderBy?:string;orderDir?:'asc'|'desc';filters?:RowFilters;}export interface IDatabase extends IDatabaseDriver{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?:QueryOptions):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<MutationResult>>;insertRows(table:string,rows:WhereClause[][]):Promise<Result<{inserted:number;skipped:number;}>>;updateRow(table:string,fields:WhereClause[],where:WhereClause[]):Promise<Result<MutationResult>>;updateRows(table:string,rows:{fields:WhereClause[];where:WhereClause[];}[]):Promise<Result<{updated:number;}>>;deleteRow(table:string,where:WhereClause[]):Promise<Result<MutationResult>>;deleteRows(table:string,rows:WhereClause[][]):Promise<Result<{deleted:number;}>>;getRowsByPks(table:string,pks:WhereClause[][]):Promise<Result<Record<string,unknown>[]>>;getRowsByFk(table:string,column:string,value:unknown,limit?:number):Promise<Result<{rows:Record<string,unknown>[];total:number;}>>;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[]>>;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;}>>;}

package/dist/db/types.js

@@ -1,6 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INTERNAL_TABLES = void 0;
-exports.INTERNAL_TABLES = {
-    savedQueries: '_saved_queries',
-};

package/dist/index.d.ts

@@ -1 +1 @@
-export{createRouter,type AppOptions} from './app';export{createLogger,type Logger,type LogLevel} from './utils/logger';export{c,supportsColor} from './utils/colors';export{SqliteDatabase,PostgresDatabase,type IDatabase,type DatabaseDialect,type PostgresOptions,type MutationResult,type QueryOptions,type Result,type TableInfoData,type ColumnInfo,type ForeignKeyInfo,type WhereClause,type IndexInfo,type SchemaInfo,type ColumnDetail,type SavedQuery,type RowFilters,type FilterCondition,type FilterValue,type SQLInputValue} from './db/index';export{DbManager,type DbManagerOptions,type DatabaseEntry} from './db/manager';export{type ColumnDef,type IndexDef} from './sql/generator';export{type ColumnPlan,type ColumnGeneratorConfig,type GeneratorStrategyId,type StrategyDescriptor,type GenerateResult} from './data/index';export{type AuthConfig,type ResolvedAuthConfig,resolveAuthConfig,getOrCreatePersistentSecret,createSessionToken,verifySessionToken,parseCookies,constantTimeCompare,hashPassword,verifyPassword,DEFAULT_USERNAME,DEFAULT_PASSWORD_HASH,SESSION_COOKIE_NAME} from './auth/index';export{isServerlessEnvironment,createServerlessHandler,createLambdaHandler,type LambdaProxyResult} from './serverless';export{sniffMimeType,generateHexDump,analyzeBlob,isJsonString,formatJsonSafely,type MimeAnalysis,type HexDumpLine,type HexDumpResult,type BlobMetadata} from './utils/datatype';export * from './types/api';
+export{createRouter,type AppOptions} from './app';export{createLogger,type Logger,type LogLevel} from './utils/logger';export{c,supportsColor} from './utils/colors';export{SqliteDatabase,PostgresDatabase,getDialect,type IDatabase,type IDialect,type ISchemaIntrospector,type IDdlGenerator,type DialectCapabilities,type DatabaseDialect,type PostgresOptions,type MutationResult,type QueryOptions,type Result,type TableInfoData,type ColumnInfo,type ForeignKeyInfo,type WhereClause,type IndexInfo,type SchemaInfo,type ColumnDetail,type RowFilters,type FilterCondition,type FilterValue,type SQLInputValue} from './db/index';export{DbManager,type DbManagerOptions,type DatabaseEntry} from './db/manager';export{type ColumnDef,type IndexDef} from './sql/generator';export{type ColumnPlan,type ColumnGeneratorConfig,type GeneratorStrategyId,type StrategyDescriptor,type GenerateResult} from './data/index';export{type AuthConfig,type ResolvedAuthConfig,resolveAuthConfig,getOrCreatePersistentSecret,createSessionToken,verifySessionToken,parseCookies,constantTimeCompare,hashPassword,verifyPassword,DEFAULT_USERNAME,DEFAULT_PASSWORD_HASH,SESSION_COOKIE_NAME} from './auth/index';export{isServerlessEnvironment,createServerlessHandler,createLambdaHandler,type LambdaProxyResult} from './serverless';export{sniffMimeType,generateHexDump,analyzeBlob,isJsonString,formatJsonSafely,type MimeAnalysis,type HexDumpLine,type HexDumpResult,type BlobMetadata} from './utils/datatype';export * from './core/index';export * from './modules/index';export * from './types/api';

package/dist/index.js

@@ -14,7 +14,7 @@ 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.formatJsonSafely = exports.isJsonString = exports.analyzeBlob = exports.generateHexDump = exports.sniffMimeType = exports.createLambdaHandler = exports.createServerlessHandler = exports.isServerlessEnvironment = exports.SESSION_COOKIE_NAME = exports.DEFAULT_PASSWORD_HASH = exports.DEFAULT_USERNAME = exports.verifyPassword = exports.hashPassword = exports.constantTimeCompare = exports.parseCookies = exports.verifySessionToken = exports.createSessionToken = exports.getOrCreatePersistentSecret = exports.resolveAuthConfig = exports.DbManager = exports.PostgresDatabase = exports.SqliteDatabase = exports.supportsColor = exports.c = exports.createLogger = exports.createRouter = void 0;
+exports.formatJsonSafely = exports.isJsonString = exports.analyzeBlob = exports.generateHexDump = exports.sniffMimeType = exports.createLambdaHandler = exports.createServerlessHandler = exports.isServerlessEnvironment = exports.SESSION_COOKIE_NAME = exports.DEFAULT_PASSWORD_HASH = exports.DEFAULT_USERNAME = exports.verifyPassword = exports.hashPassword = exports.constantTimeCompare = exports.parseCookies = exports.verifySessionToken = exports.createSessionToken = exports.getOrCreatePersistentSecret = exports.resolveAuthConfig = exports.DbManager = exports.getDialect = exports.PostgresDatabase = exports.SqliteDatabase = exports.supportsColor = exports.c = exports.createLogger = exports.createRouter = void 0;
 var app_1 = require("./app");
 Object.defineProperty(exports, "createRouter", { enumerable: true, get: function () { return app_1.createRouter; } });
 var logger_1 = require("./utils/logger");
@@ -25,6 +25,7 @@ Object.defineProperty(exports, "supportsColor", { enumerable: true, get: functio
 var index_1 = require("./db/index");
 Object.defineProperty(exports, "SqliteDatabase", { enumerable: true, get: function () { return index_1.SqliteDatabase; } });
 Object.defineProperty(exports, "PostgresDatabase", { enumerable: true, get: function () { return index_1.PostgresDatabase; } });
+Object.defineProperty(exports, "getDialect", { enumerable: true, get: function () { return index_1.getDialect; } });
 var manager_1 = require("./db/manager");
 Object.defineProperty(exports, "DbManager", { enumerable: true, get: function () { return manager_1.DbManager; } });
 var index_2 = require("./auth/index");
@@ -49,4 +50,6 @@ Object.defineProperty(exports, "generateHexDump", { enumerable: true, get: funct
 Object.defineProperty(exports, "analyzeBlob", { enumerable: true, get: function () { return datatype_1.analyzeBlob; } });
 Object.defineProperty(exports, "isJsonString", { enumerable: true, get: function () { return datatype_1.isJsonString; } });
 Object.defineProperty(exports, "formatJsonSafely", { enumerable: true, get: function () { return datatype_1.formatJsonSafely; } });
+__exportStar(require("./core/index"), exports);
+__exportStar(require("./modules/index"), exports);
 __exportStar(require("./types/api"), exports);

package/dist/modules/databases/databases.routes.d.ts

@@ -0,0 +1 @@
+import type {Router} from 'express';import type {DbManager} from '../../db/manager';import type {Logger} from '../../utils/logger';import{type DatabaseRow,type FsEntry} from './databases.service';export type {DatabaseRow,FsEntry};export interface DatabasesRoutesContext{manager:DbManager;logger:Logger;basePath:string;readonly ?:boolean;allowBrowse?:boolean;browseRoot?:string;invalidate?:(id:string)=>void;}export declare function registerDatabasesRoutes(router:Router,ctx:DatabasesRoutesContext):void;

package/dist/modules/databases/databases.routes.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDatabasesRoutes = registerDatabasesRoutes;
+const node_path_1 = __importDefault(require("node:path"));
+const common_1 = require("../../utils/common");
+const databases_service_1 = require("./databases.service");
+function registerDatabasesRoutes(router, ctx) {
+    const { manager } = ctx;
+    const allowBrowse = ctx.allowBrowse ?? true;
+    const browseRoot = ctx.browseRoot ? node_path_1.default.resolve(ctx.browseRoot) : undefined;
+    const wrap = (fn) => async (req, res) => {
+        try {
+            await fn(req, res);
+        }
+        catch (err) {
+            res.status(500).json({ success: false, error: (0, common_1.errorMessage)(err) });
+        }
+    };
+    router.get('/', async (_req, res, next) => {
+        try {
+            res.locals.databasesMode = true;
+            res.render('pages/databases', {
+                title: 'Databases',
+                databasesMode: true,
+                databases: await databases_service_1.DatabasesService.getDatabaseRows(manager),
+                dbDir: manager.directory,
+                readonly: Boolean(ctx.readonly),
+                allowBrowse,
+                browseRoot,
+                config: { basePath: ctx.basePath },
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/api/databases', wrap(async (_req, res) => {
+        res.json({ success: true, data: await databases_service_1.DatabasesService.getDatabaseRows(manager) });
+    }));
+    router.get('/api/fs/list', wrap(async (req, res) => {
+        if (!allowBrowse) {
+            return res.status(403).json({
+                success: false,
+                error: 'File browsing is disabled — this server was started with specific database files.',
+            });
+        }
+        const raw = String(req.query.path ?? '').trim();
+        const base = raw ? node_path_1.default.resolve(raw) : manager.directory;
+        try {
+            const data = databases_service_1.DatabasesService.listDirectory(base, manager, browseRoot);
+            res.json({ success: true, data });
+        }
+        catch (err) {
+            const msg = (0, common_1.errorMessage)(err);
+            if (msg.includes('outside the allowed folder'))
+                return res.status(403).json({ success: false, error: msg });
+            if (msg.includes('does not exist'))
+                return res.status(404).json({ success: false, error: msg });
+            return res.status(400).json({ success: false, error: msg });
+        }
+    }));
+    router.post('/api/databases/open', wrap(async (req, res) => {
+        if (!allowBrowse) {
+            return res.status(403).json({
+                success: false,
+                error: 'File browsing is disabled — this server was started with specific database files.',
+            });
+        }
+        const p = String(req.body?.path ?? '').trim();
+        const isRo = req.body?.readonly !== undefined ? Boolean(req.body.readonly) : undefined;
+        try {
+            const id = databases_service_1.DatabasesService.openDatabaseFile(manager, p, isRo, browseRoot);
+            res.json({ success: true, data: { id, message: `Opened "${id}".` } });
+        }
+        catch (err) {
+            const msg = (0, common_1.errorMessage)(err);
+            if (msg.includes('outside the allowed folder'))
+                return res.status(403).json({ success: false, error: msg });
+            return res.status(400).json({ success: false, error: msg });
+        }
+    }));
+    router.post('/api/databases/connect-postgres', wrap(async (req, res) => {
+        if (ctx.readonly)
+            return res.status(403).json({ success: false, error: 'Read-only mode — adding connections is disabled.' });
+        const name = String(req.body?.name ?? '').trim();
+        const connectionString = String(req.body?.connectionString ?? req.body?.connection ?? '').trim();
+        const isRo = Boolean(req.body?.readonly);
+        try {
+            const id = await databases_service_1.DatabasesService.connectPostgres(manager, name, connectionString, isRo);
+            res.status(201).json({ success: true, data: { id, message: `Connected to PostgreSQL database "${id}".` } });
+        }
+        catch (err) {
+            res.status(400).json({ success: false, error: (0, common_1.errorMessage)(err) });
+        }
+    }));
+    router.post('/api/databases/:id/mode', wrap(async (req, res) => {
+        if (ctx.readonly && req.body?.readonly === false) {
+            return res.status(403).json({ success: false, error: 'Server is in global read-only mode.' });
+        }
+        const id = String(req.params.id);
+        const targetRo = Boolean(req.body?.readonly);
+        try {
+            databases_service_1.DatabasesService.setDatabaseMode(manager, id, targetRo, ctx.invalidate);
+            res.json({
+                success: true,
+                data: {
+                    id,
+                    readonly: targetRo,
+                    message: `Database "${id}" mode set to ${targetRo ? 'Read-only' : 'Writable'}.`,
+                },
+            });
+        }
+        catch (err) {
+            const msg = (0, common_1.errorMessage)(err);
+            if (msg.includes('does not exist'))
+                return res.status(404).json({ success: false, error: msg });
+            res.status(400).json({ success: false, error: msg });
+        }
+    }));
+    router.post('/api/databases', wrap(async (req, res) => {
+        if (ctx.readonly)
+            return res.status(403).json({ success: false, error: 'Read-only mode — creating databases is disabled.' });
+        const name = String(req.body?.name ?? '').trim();
+        try {
+            const id = databases_service_1.DatabasesService.createDatabase(manager, name);
+            res.status(201).json({ success: true, data: { id, message: `Database "${id}" created.` } });
+        }
+        catch (err) {
+            res.status(400).json({ success: false, error: (0, common_1.errorMessage)(err) });
+        }
+    }));
+    router.delete('/api/databases/:id', wrap(async (req, res) => {
+        if (ctx.readonly)
+            return res.status(403).json({ success: false, error: 'Read-only mode — deleting databases is disabled.' });
+        const id = String(req.params.id);
+        try {
+            databases_service_1.DatabasesService.removeDatabase(manager, id, ctx.invalidate);
+            res.json({ success: true, data: { message: `Database "${id}" removed.` } });
+        }
+        catch (err) {
+            const msg = (0, common_1.errorMessage)(err);
+            if (msg.includes('does not exist'))
+                return res.status(404).json({ success: false, error: msg });
+            res.status(400).json({ success: false, error: msg });
+        }
+    }));
+}

package/dist/modules/databases/databases.service.d.ts

@@ -0,0 +1 @@
+import type {DbManager} from '../../db/manager';import type {DatabaseRow,FsEntry} from '../../types/api';export type {DatabaseRow,FsEntry};export declare class DatabasesService{static getDatabaseRows(manager:DbManager):Promise<DatabaseRow[]>;static listDirectory(base:string,manager:DbManager,browseRoot?:string):{path:string;name:string;parent:string|null;entries:FsEntry[];};static openDatabaseFile(manager:DbManager,filePath:string,isRo?:boolean,browseRoot?:string):string;static connectPostgres(manager:DbManager,name:string,connectionString:string,isRo?:boolean):Promise<string>;static createDatabase(manager:DbManager,name:string):string;static setDatabaseMode(manager:DbManager,id:string,readonly :boolean,invalidate?:(id:string)=>void):void;static removeDatabase(manager:DbManager,id:string,invalidate?:(id:string)=>void):void;}