admindb 2.4.0 → 2.5.0

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

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteIntrospector = void 0;
+const generator_1 = require("../../../sql/generator");
+class SqliteIntrospector {
+    getNativeDb(driver) {
+        if (driver && typeof driver === 'object' && 'db' in driver) {
+            return driver.db;
+        }
+        return driver;
+    }
+    async listTables(driver) {
+        try {
+            const db = this.getNativeDb(driver);
+            const rows = db
+                .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
+                .all();
+            return { success: true, data: rows.map((r) => ({ name: r.name })) };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    getTableNames(db) {
+        return db
+            .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'")
+            .all().map((r) => r.name);
+    }
+    getIncomingFks(db, targetTable) {
+        const refs = [];
+        for (const t of this.getTableNames(db)) {
+            if (t === targetTable)
+                continue;
+            try {
+                const fks = db.prepare(`PRAGMA foreign_key_list(${(0, generator_1.quoteIdentifier)(t)})`).all();
+                for (const fk of fks) {
+                    if (fk.table === targetTable)
+                        refs.push({ table: t, from: fk.from, to: fk.to ?? '' });
+                }
+            }
+            catch { }
+        }
+        return refs;
+    }
+    async getTableInfo(driver, table) {
+        try {
+            const db = this.getNativeDb(driver);
+            const cols = db.prepare(`PRAGMA table_info(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            const fks = db.prepare(`PRAGMA foreign_key_list(${(0, generator_1.quoteIdentifier)(table)})`).all();
+            const primaryKey = cols
+                .filter((c) => c.pk > 0)
+                .sort((a, b) => a.pk - b.pk)
+                .map((c) => c.name);
+            const indexRows = db
+                .prepare(`PRAGMA index_list(${(0, generator_1.quoteIdentifier)(table)})`)
+                .all();
+            const indexes = indexRows.map((ix) => {
+                const ixCols = db.prepare(`PRAGMA index_info(${(0, generator_1.quoteIdentifier)(ix.name)})`).all().map((c) => c.name);
+                const sqlRow = db
+                    .prepare("SELECT sql FROM sqlite_master WHERE type = 'index' AND name = ?")
+                    .get(ix.name);
+                return {
+                    name: ix.name,
+                    unique: Boolean(ix.unique),
+                    partial: ix.partial,
+                    origin: ix.origin,
+                    columns: ixCols,
+                    sql: sqlRow?.sql ?? null,
+                };
+            });
+            const ddlRow = db
+                .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?")
+                .get(table);
+            return {
+                success: true,
+                data: {
+                    table,
+                    columns: cols.map((c) => ({
+                        cid: c.cid,
+                        name: c.name,
+                        type: c.type,
+                        notnull: c.notnull,
+                        dflt_value: c.dflt_value,
+                        pk: c.pk,
+                    })),
+                    foreignKeys: fks.map((f) => ({
+                        id: f.id,
+                        seq: f.seq,
+                        table: f.table,
+                        from: f.from,
+                        to: f.to,
+                        on_update: f.on_update,
+                        on_delete: f.on_delete,
+                    })),
+                    primaryKey,
+                    indexes,
+                    sql: ddlRow?.sql ?? null,
+                },
+            };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getSchema(driver, table) {
+        try {
+            const db = this.getNativeDb(driver);
+            const infoRes = await this.getTableInfo(driver, table);
+            if (!infoRes.success || !infoRes.data || infoRes.data.columns.length === 0) {
+                return { success: false, error: `Table "${table}" does not exist.` };
+            }
+            const info = infoRes.data;
+            const { foreignKeys, indexes } = info;
+            const uniqueCols = new Set();
+            const indexedCols = new Set();
+            for (const ix of indexes) {
+                if (ix.unique)
+                    ix.columns.forEach((c) => uniqueCols.add(c));
+                if (ix.origin === 'c')
+                    ix.columns.forEach((c) => indexedCols.add(c));
+            }
+            const refs = this.getIncomingFks(db, table);
+            const refsByTo = new Map();
+            for (const r of refs) {
+                const arr = refsByTo.get(r.to) ?? [];
+                arr.push({ table: r.table, from: r.from });
+                refsByTo.set(r.to, arr);
+            }
+            const fkByFrom = new Map(foreignKeys.map((fk) => [fk.from, fk]));
+            const columns = info.columns.map((c) => {
+                const unique = c.pk > 0 || uniqueCols.has(c.name);
+                const indexed = indexedCols.has(c.name);
+                const referencedBy = refsByTo.get(c.name) ?? [];
+                const fk = fkByFrom.get(c.name) ?? null;
+                const dropBlockers = [];
+                if (c.pk > 0)
+                    dropBlockers.push('Is part of the primary key');
+                if (unique && c.pk === 0)
+                    dropBlockers.push('Has a UNIQUE constraint');
+                if (indexed)
+                    dropBlockers.push('Is used by an index');
+                if (referencedBy.length)
+                    dropBlockers.push(`Referenced by a foreign key in "${referencedBy[0].table}"`);
+                if (fk)
+                    dropBlockers.push('Is part of a foreign key');
+                return {
+                    ...c,
+                    unique,
+                    indexed,
+                    referencedBy,
+                    fk,
+                    canDrop: dropBlockers.length === 0,
+                    dropBlockers,
+                };
+            });
+            return {
+                success: true,
+                data: {
+                    table,
+                    columns,
+                    foreignKeys,
+                    indexes,
+                    references: refs,
+                },
+            };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getReferencingTables(driver, table) {
+        try {
+            const db = this.getNativeDb(driver);
+            const refs = this.getIncomingFks(db, table);
+            const byTable = new Map();
+            for (const r of refs) {
+                const arr = byTable.get(r.table) ?? [];
+                arr.push({ from: r.from, to: r.to });
+                byTable.set(r.table, arr);
+            }
+            const result = [];
+            for (const [t, tRefs] of byTable) {
+                let refCount = 0;
+                try {
+                    const conds = tRefs.map((r) => `${(0, generator_1.quoteIdentifier)(r.from)} IS NOT NULL`);
+                    const row = db
+                        .prepare(`SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(t)} WHERE ${conds.join(' OR ')}`)
+                        .get();
+                    refCount = Number(row.c);
+                }
+                catch { }
+                result.push({ table: t, refs: tRefs, refCount });
+            }
+            result.sort((a, b) => a.table.localeCompare(b.table));
+            return { success: true, data: result };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async getCreateStatement(driver, table) {
+        try {
+            const db = this.getNativeDb(driver);
+            const row = db
+                .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?")
+                .get(table);
+            return { success: true, data: row?.sql ?? null };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+}
+exports.SqliteIntrospector = SqliteIntrospector;

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

@@ -0,0 +1 @@
+export declare const SQLITE_DESIGNER_TYPES:readonly ["TEXT","INTEGER","REAL","BLOB","BOOLEAN","DATE","DATETIME","NUMERIC","VARCHAR(255)","JSON"];import type {MappedType} from '../types';export type {MappedType};export declare function mapSqliteColumnType(type:string):MappedType;

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

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

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

@@ -0,0 +1 @@
+import type {Result} from '../../core/result';import type {ColumnDef,IndexDef} from '../../sql/generator';import type {DatabaseDialect,MutationResult,ReferencingTableInfo,SchemaInfo,SQLInputValue,TableInfoData,TableListItem} from '../types';export interface MappedType{sqlType:string;defaultAuto?:string;}export interface DialectCapabilities{supportsCascadeDrop:boolean;supportsNativeAlterColumn:boolean;supportsRegexFilter:boolean;supportsJsonb:boolean;}export declare const SQLITE_CAPABILITIES:DialectCapabilities;export declare const POSTGRES_CAPABILITIES:DialectCapabilities;export interface IDatabaseDriver{readonly dialect:DatabaseDialect;readonly isReadOnly:boolean;readonly path:string;all<T=unknown>(sql:string,params?:SQLInputValue[]):Promise<Result<T[]>>;run(sql:string,params?:SQLInputValue[]):Promise<Result<MutationResult>>;execResult(sql:string):Promise<Result<{changes?:number;}>>;close():Promise<void>|void;}export interface ISchemaIntrospector<D=unknown>{listTables(driver:D):Promise<Result<TableListItem[]>>;getTableInfo(driver:D,table:string):Promise<Result<TableInfoData>>;getSchema(driver:D,table:string):Promise<Result<SchemaInfo>>;getReferencingTables(driver:D,table:string):Promise<Result<ReferencingTableInfo[]>>;getCreateStatement(driver:D,table:string):Promise<Result<string|null>>;getColumnCountMap?(driver:D):Promise<Result<Record<string,number>>>;}export interface IDdlGenerator<D=unknown>{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;setForeignKeys?(enabled:boolean):string;addColumn(table:string,column:ColumnDef):string;modifyColumn(driver:D,table:string,oldCol:string,newCol:ColumnDef):Promise<Result<{changes?:number;}>>;renameColumn(table:string,oldName:string,newName:string):string;dropColumn(table:string,column:string):string;createIndex(table:string,index:IndexDef):string;dropIndex(indexName:string):string;}export interface IDialect<D=unknown>{readonly name:DatabaseDialect;readonly introspector:ISchemaIntrospector<D>;readonly ddl:IDdlGenerator<D>;readonly capabilities:DialectCapabilities;quoteIdentifier(identifier:string):string;mapType(type:string):{sqlType:string;defaultAuto?:string;};getDesignerTypes():readonly string[];}

package/dist/db/dialects/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POSTGRES_CAPABILITIES = exports.SQLITE_CAPABILITIES = void 0;
+exports.SQLITE_CAPABILITIES = {
+    supportsCascadeDrop: false,
+    supportsNativeAlterColumn: false,
+    supportsRegexFilter: false,
+    supportsJsonb: false,
+};
+exports.POSTGRES_CAPABILITIES = {
+    supportsCascadeDrop: true,
+    supportsNativeAlterColumn: true,
+    supportsRegexFilter: true,
+    supportsJsonb: true,
+};

package/dist/db/export.js

@@ -28,7 +28,7 @@ async function generateSqlDump(db) {
 async function generateSchemaDump(db) {
     const out = [];
     if (db.dialect === 'sqlite') {
-        const allSchemas = await db.all(`SELECT sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '_saved_queries'`);
+        const allSchemas = await db.all(`SELECT sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%'`);
         if (!allSchemas.success || !allSchemas.data) {
             return { success: false, error: allSchemas.error ?? 'Failed to read sqlite_master.' };
         }

package/dist/db/index.d.ts

@@ -1 +1 @@
-export * from './types';export * from './filters';export * from './introspection';export * from './migrations';export * from './database';export * from './postgres';export * from './manager';export * from './export';
+export * from './types';export * from './filters';export * from './migrations';export * from './database';export * from './postgres';export * from './manager';export * from './export';export * from './dialects/index';export type {DatabaseContext} from '../core/context';

package/dist/db/index.js

@@ -16,9 +16,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
 __exportStar(require("./filters"), exports);
-__exportStar(require("./introspection"), exports);
 __exportStar(require("./migrations"), exports);
 __exportStar(require("./database"), exports);
 __exportStar(require("./postgres"), exports);
 __exportStar(require("./manager"), exports);
 __exportStar(require("./export"), exports);
+__exportStar(require("./dialects/index"), exports);

package/dist/db/manager.d.ts

@@ -1 +1 @@
-import type {IDatabase} from './types';import{type Logger} from '../utils/logger';export interface DbManagerOptions{dir?:string;files?:string[];connections?:Record<string,string>;readonly ?:boolean;serverless?:boolean;}export interface DatabaseEntry{id:string;name:string;path:string;dialect:'sqlite'|'postgres';size:number;modified:string;readonly :boolean;}export declare class DbManager{private logger;private dir?;private createDir;private readonly readonlyMode;private readonly isServerless;private files;private idByPath;private pathById;private nameById;private readonlyById;private openDbs;constructor(options:DbManagerOptions|string,logger?:Logger);get directory():string;get isReadOnly():boolean;isDbFile(name:string):boolean;private registerConnections;private registerDirFiles;private registerExplicitFiles;private addNamedTarget;private addFile;list():DatabaseEntry[];has(id:string):boolean;isDbReadOnly(id:string):boolean;setReadonly(id:string,readonly :boolean):void;open(id:string,readonlyOverride?:boolean):IDatabase;openFile(absPath:string,readonly ?:boolean):string;get(id:string):IDatabase|undefined;countTables(id:string):Promise<number>;create(name:string):string;addConnection(name:string,connectionString:string,readonly ?:boolean):string;remove(id:string):void;closeAll():void;}
+import type {IDatabase} from './types';import{type Logger} from '../utils/logger';import type {DatabaseContext} from '../core/context';export interface DbManagerOptions{dir?:string;files?:string[];connections?:Record<string,string>;readonly ?:boolean;serverless?:boolean;maxOpenDbs?:number;idleTimeoutMs?:number;}export interface DatabaseEntry{id:string;name:string;path:string;dialect:'sqlite'|'postgres';size:number;modified:string;readonly :boolean;}export declare class DbManager{private logger;private dir?;private createDir;private readonly readonlyMode;private readonly isServerless;private readonly maxOpenDbs;private readonly idleTimeoutMs;private files;private idByPath;private pathById;private nameById;private readonlyById;private openDbs;private accessOrder;private lastAccessed;constructor(options:DbManagerOptions|string,logger?:Logger);get directory():string;get isReadOnly():boolean;isDbFile(name:string):boolean;private registerConnections;private registerDirFiles;private registerExplicitFiles;private addNamedTarget;private addFile;list():DatabaseEntry[];has(id:string):boolean;isDbReadOnly(id:string):boolean;private touch;private evictLru;pruneIdle(maxIdleAgeMs?:number):number;closeDb(id:string):void;getPoolStats():{openConnections:number;maxOpenDbs:number;lruOrder:string[];};setReadonly(id:string,readonly :boolean):void;open(id:string,readonlyOverride?:boolean):IDatabase;getContext(id:string,readonlyOverride?:boolean):DatabaseContext;openFile(absPath:string,readonly ?:boolean):string;get(id:string):IDatabase|undefined;countTables(id:string):Promise<number>;create(name:string):string;addConnection(name:string,connectionString:string,readonly ?:boolean):string;remove(id:string):void;closeAll():void;}

package/dist/db/manager.js

@@ -11,6 +11,7 @@ const postgres_1 = require("./postgres");
 const logger_1 = require("../utils/logger");
 const common_1 = require("../utils/common");
 const serverless_1 = require("../serverless");
+const index_1 = require("./dialects/index");
 const DB_EXTENSIONS = ['.db', '.sqlite', '.sqlite3'];
 class DbManager {
     logger;
@@ -18,12 +19,16 @@ class DbManager {
     createDir;
     readonlyMode;
     isServerless;
+    maxOpenDbs;
+    idleTimeoutMs;
     files = [];
     idByPath = new Map();
     pathById = new Map();
     nameById = new Map();
     readonlyById = new Map();
     openDbs = new Map();
+    accessOrder = [];
+    lastAccessed = new Map();
     constructor(options, logger) {
         const opts = typeof options === 'string' ? { dir: options } : (options ?? {});
         this.logger = logger ?? (0, logger_1.createLogger)('info', 'admindb');
@@ -31,6 +36,8 @@ class DbManager {
         this.createDir = this.dir ?? process.cwd();
         this.readonlyMode = Boolean(opts.readonly);
         this.isServerless = opts.serverless !== undefined ? opts.serverless : (0, serverless_1.isServerlessEnvironment)();
+        this.maxOpenDbs = Math.max(1, opts.maxOpenDbs ?? 25);
+        this.idleTimeoutMs = Math.max(0, opts.idleTimeoutMs ?? 0);
         if (this.dir)
             (0, node_fs_1.mkdirSync)(this.dir, { recursive: true });
         if (opts.connections)
@@ -171,6 +178,70 @@ class DbManager {
         }
         return false;
     }
+    touch(id) {
+        const idx = this.accessOrder.indexOf(id);
+        if (idx !== -1) {
+            this.accessOrder.splice(idx, 1);
+        }
+        this.accessOrder.push(id);
+        this.lastAccessed.set(id, Date.now());
+    }
+    evictLru() {
+        while (this.accessOrder.length > 0) {
+            const oldestId = this.accessOrder.shift();
+            const db = this.openDbs.get(oldestId);
+            if (db) {
+                this.logger.debug?.(`Evicting idle database connection "${oldestId}" from pool.`);
+                try {
+                    db.close();
+                }
+                catch (err) {
+                    this.logger.warn(`Error closing evicted database "${oldestId}": ${(0, common_1.errorMessage)(err)}`);
+                }
+                this.openDbs.delete(oldestId);
+                this.lastAccessed.delete(oldestId);
+                return true;
+            }
+        }
+        return false;
+    }
+    pruneIdle(maxIdleAgeMs) {
+        const maxAge = maxIdleAgeMs ?? this.idleTimeoutMs;
+        if (maxAge <= 0)
+            return 0;
+        const now = Date.now();
+        let pruned = 0;
+        for (const [id, lastTime] of Array.from(this.lastAccessed.entries())) {
+            if (now - lastTime > maxAge) {
+                this.closeDb(id);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    closeDb(id) {
+        const db = this.openDbs.get(id);
+        if (db) {
+            try {
+                db.close();
+            }
+            catch (err) {
+                this.logger.warn(`Error closing database "${id}": ${(0, common_1.errorMessage)(err)}`);
+            }
+            this.openDbs.delete(id);
+        }
+        const idx = this.accessOrder.indexOf(id);
+        if (idx !== -1)
+            this.accessOrder.splice(idx, 1);
+        this.lastAccessed.delete(id);
+    }
+    getPoolStats() {
+        return {
+            openConnections: this.openDbs.size,
+            maxOpenDbs: this.maxOpenDbs,
+            lruOrder: [...this.accessOrder],
+        };
+    }
     setReadonly(id, readonly) {
         if (this.readonlyMode && !readonly) {
             throw new Error('Manager is in global read-only mode — databases cannot be made writable.');
@@ -185,14 +256,7 @@ class DbManager {
         if (this.readonlyById.get(id) === readonly)
             return;
         this.readonlyById.set(id, readonly);
-        const db = this.openDbs.get(id);
-        if (db) {
-            try {
-                db.close();
-            }
-            catch { }
-            this.openDbs.delete(id);
-        }
+        this.closeDb(id);
     }
     open(id, readonlyOverride) {
         const target = this.pathById.get(id);
@@ -201,22 +265,43 @@ class DbManager {
         const isRo = readonlyOverride !== undefined ? readonlyOverride : this.isDbReadOnly(id);
         let db = this.openDbs.get(id);
         if (db && db.isReadOnly !== isRo) {
-            try {
-                db.close();
-            }
-            catch { }
-            this.openDbs.delete(id);
+            this.closeDb(id);
             db = undefined;
         }
         if (!db) {
+            if (this.idleTimeoutMs > 0) {
+                this.pruneIdle();
+            }
+            while (this.openDbs.size >= this.maxOpenDbs) {
+                if (!this.evictLru())
+                    break;
+            }
             const childLogger = this.logger.child(`db:${id}`);
             db = (0, common_1.isPostgresConnectionString)(target)
                 ? new postgres_1.PostgresDatabase(target, childLogger, { readonly: isRo })
                 : new database_1.SqliteDatabase(target, childLogger, { readonly: isRo });
             this.openDbs.set(id, db);
         }
+        this.touch(id);
         return db;
     }
+    getContext(id, readonlyOverride) {
+        const db = this.open(id, readonlyOverride);
+        const target = this.pathById.get(id);
+        const isPg = (0, common_1.isPostgresConnectionString)(target);
+        const schema = isPg ? db.schema || 'public' : undefined;
+        const dialect = (0, index_1.getDialect)(isPg ? 'postgres' : 'sqlite', schema);
+        return {
+            id,
+            name: this.nameById.get(id) ?? id,
+            path: db.path,
+            db,
+            dialect,
+            capabilities: dialect.capabilities,
+            isReadOnly: db.isReadOnly,
+            logger: this.logger.child(`db:${id}`),
+        };
+    }
     openFile(absPath, readonly) {
         const abs = node_path_1.default.resolve(String(absPath ?? '').trim());
         if (!abs)
@@ -303,14 +388,7 @@ class DbManager {
         const target = this.pathById.get(id);
         if (!target)
             return;
-        const db = this.openDbs.get(id);
-        if (db) {
-            try {
-                db.close();
-            }
-            catch { }
-            this.openDbs.delete(id);
-        }
+        this.closeDb(id);
         this.pathById.delete(id);
         this.idByPath.delete(target);
         this.nameById.delete(id);
@@ -333,6 +411,8 @@ class DbManager {
             catch { }
         }
         this.openDbs.clear();
+        this.accessOrder = [];
+        this.lastAccessed.clear();
     }
 }
 exports.DbManager = DbManager;

package/dist/db/postgres.d.ts

@@ -1 +1 @@
-import type {Logger} from '../utils/logger';import{type ColumnDef,type IndexDef} from '../sql/generator';import type {DatabaseDialect,IDatabase,MutationResult,PostgresOptions,QueryOptions,ReferencingTableInfo,Result,RowFilters,SavedQuery,SchemaInfo,SQLInputValue,TableInfoData,TableListItem,WhereClause} from './types';export declare class PostgresDatabase implements IDatabase{private pool;private logger;readonly path:string;readonly isReadOnly:boolean;readonly dialect:DatabaseDialect;readonly schema:string;constructor(connection:string|PostgresOptions,logger:Logger,options?:PostgresOptions);private readonlyBlocked;close():Promise<void>;private tryRun;private transaction;private initSchema;hasMultipleStatements(sql:string):boolean;all(sql:string,params?:SQLInputValue[]):Promise<Result<unknown[]>>;run(sql:string,params?:SQLInputValue[]):Promise<Result<MutationResult>>;execResult(sql:string):Promise<Result<{changes?:number;}>>;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 {Logger} from '../utils/logger';import{type ColumnDef,type IndexDef} from '../sql/generator';import type {DatabaseDialect,IDatabase,MutationResult,PostgresOptions,QueryOptions,ReferencingTableInfo,Result,RowFilters,SchemaInfo,SQLInputValue,TableInfoData,TableListItem,WhereClause} from './types';import type {IDialect} from './dialects/types';export declare class PostgresDatabase implements IDatabase{private pool;private logger;readonly path:string;readonly isReadOnly:boolean;readonly dialect:DatabaseDialect;readonly schema:string;readonly dialectInstance:IDialect;constructor(connection:string|PostgresOptions,logger:Logger,options?:PostgresOptions);private readonlyBlocked;close():Promise<void>;private tryRun;private transaction;hasMultipleStatements(sql:string):boolean;all<T=unknown>(sql:string,params?:SQLInputValue[]):Promise<Result<T[]>>;run(sql:string,params?:SQLInputValue[]):Promise<Result<MutationResult>>;execResult(sql:string):Promise<Result<{changes?:number;}>>;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;}>>;}