admindb 2.3.0 → 2.3.1

package/README.md

@@ -4,7 +4,7 @@
 [![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
 [![Downloads](https://img.shields.io/npm/dm/admindb.svg)](https://www.npmjs.com/package/admindb)
-[![Publish](https://github.com/MIbnEKhalid/admindb/actions/workflows/publish.yml/badge.svg?branch=main)](https://github.com/MIbnEKhalid/admindb/actions/workflows/publish.yml)
+[![Check npm version](https://github.com/MIbnEKhalid/mbkauthe/actions/workflows/checkLatestVersion.yml/badge.svg)](https://github.com/MIbnEKhalid/mbkauthe/actions/workflows/checkLatestVersion.yml)
 
 **A modern, browser-based SQLite and PostgreSQL database administration tool.** Manage SQLite and PostgreSQL databases entirely from your browser — browse and edit rows, run arbitrary SQL queries, design schemas visually, seed realistic test data, inspect complex data types, and import/export CSV/JSON — with zero frontend build step.
 

package/dist/app.js

@@ -68,18 +68,29 @@ function addErrorHandlers(app, logger) {
 }
 function createSingleDbApp(options) {
     const isServerless = options.serverless !== undefined ? options.serverless : (0, serverless_1.isServerlessEnvironment)();
-    const rawTarget = options.connection || options.dbPath || '';
+    const envTarget = process.env.ADMINDB_CONNECTION ||
+        process.env.DATABASE_URL ||
+        process.env.POSTGRES_URL ||
+        process.env.PG_CONNECTION ||
+        '';
+    const rawTarget = options.connection || options.dbPath || ((0, common_1.isPostgresConnectionString)(envTarget) ? envTarget : '');
     const isPg = Boolean(options.pgOptions) ||
         (0, common_1.isPostgresConnectionString)(rawTarget) ||
         options.db?.dialect === 'postgres';
     const readonly = options.readonly !== undefined
         ? Boolean(options.readonly)
-        : (isServerless && !isPg);
+        : (isServerless ? !isPg : false);
     const basePath = (options.basePath ?? '').replace(/\/+$/, '');
     const logger = options.logger ?? (0, logger_1.createLogger)(options.logLevel ?? 'info', 'admindb');
     let db;
     if (options.db) {
         db = options.db;
+        if (options.readonly !== undefined && db.isReadOnly !== Boolean(options.readonly)) {
+            try {
+                Object.defineProperty(db, 'isReadOnly', { value: Boolean(options.readonly), configurable: true });
+            }
+            catch { }
+        }
     }
     else if (isPg) {
         db = new postgres_1.PostgresDatabase(options.pgOptions || rawTarget, logger, { readonly });
@@ -135,8 +146,9 @@ function createSingleDbApp(options) {
 }
 function createManagerApp(options) {
     const isServerless = options.serverless !== undefined ? options.serverless : (0, serverless_1.isServerlessEnvironment)();
-    const readonly = isServerless || Boolean(options.readonly);
+    const explicitReadonly = options.readonly !== undefined ? Boolean(options.readonly) : undefined;
     const manager = options.manager;
+    const globalReadonly = explicitReadonly ?? manager.isReadOnly;
     const basePath = (options.basePath ?? '').replace(/\/+$/, '');
     const logger = options.logger ?? (0, logger_1.createLogger)(options.logLevel ?? 'info', 'admindb');
     const authConfig = (0, auth_1.resolveAuthConfig)(options.auth);
@@ -157,7 +169,7 @@ function createManagerApp(options) {
             res.locals.dbId = null;
             res.locals.databasesUrl = null;
             res.locals.databasesMode = true;
-            res.locals.readonly = readonly;
+            res.locals.readonly = globalReadonly;
             res.locals.serverless = isServerless;
             res.locals.version = APP_VERSION;
             res.locals.authEnabled = authConfig.enabled;
@@ -178,7 +190,7 @@ function createManagerApp(options) {
         manager,
         logger,
         basePath,
-        readonly,
+        readonly: globalReadonly,
         allowBrowse: isServerless ? false : options.allowBrowse,
         browseRoot: options.browseRoot,
         invalidate: (id) => subApps.delete(id),
@@ -198,7 +210,7 @@ function createManagerApp(options) {
         const rawRo = req.query.readonly;
         if (rawRo !== undefined) {
             const explicitRo = rawRo === '1' || rawRo === 'true';
-            if (!readonly || explicitRo) {
+            if (!globalReadonly || explicitRo) {
                 manager.setReadonly(dbId, explicitRo);
                 subApps.delete(dbId);
             }
@@ -206,7 +218,7 @@ function createManagerApp(options) {
         let sub = subApps.get(dbId);
         if (!sub) {
             const subBase = `${basePath || ''}/${encodeURIComponent(dbId)}`;
-            const effectiveRo = readonly || manager.isDbReadOnly(dbId);
+            const effectiveRo = globalReadonly ? true : manager.isDbReadOnly(dbId);
             sub = createSingleDbApp({
                 db: manager.open(dbId, effectiveRo),
                 basePath: subBase,

package/dist/cli/args.d.ts

@@ -1 +1 @@
-import type {LogLevel} from '../utils/logger';export interface CliArgs{help:boolean;version:boolean;host?:string;port?:number;dbPath?:string;connection?:string;connections?:Record<string,string>;configPath?:string;dbDir?:string;dbFiles?:string[];basePath?:string;logLevel?:LogLevel;readonly :boolean;serverless?:boolean;auth?:boolean;authUsername?:string;authPassword?:string;authSecret?:string;}export declare function helpText():string;export declare const getPackageVersion:()=>string;export declare const versionText:()=>string;export declare function parseArgs(argv:string[]):{args:CliArgs;error?:string;};
+import type {LogLevel} from '../utils/logger';export interface CliArgs{help:boolean;version:boolean;host?:string;port?:number;dbPath?:string;connection?:string;connections?:Record<string,string>;configPath?:string;dbDir?:string;dbFiles?:string[];basePath?:string;logLevel?:LogLevel;readonly :boolean;explicitReadonly?:boolean;serverless?:boolean;auth?:boolean;authUsername?:string;authPassword?:string;authSecret?:string;}export declare function helpText():string;export declare const getPackageVersion:()=>string;export declare const versionText:()=>string;export declare function parseArgs(argv:string[]):{args:CliArgs;error?:string;};

package/dist/cli/args.js

@@ -38,7 +38,7 @@ function helpText() {
         '      --files, --db-files <list> Comma-separated database file paths [DB_FILES / ADMINDB_DB_FILES]',
         '  -b, --base-path, --base <p>    URL prefix to serve under (default: /) [BASE_PATH / ADMINDB_BASE_PATH]',
         '  -r, --readonly, --read-only    Open databases read-only (writes disabled) [READONLY / ADMINDB_READONLY]',
-        '      --serverless               Enable serverless mode (enforces read-only, disables writes) [SERVERLESS / ADMINDB_SERVERLESS]',
+        '      --serverless               Enable serverless mode (SQLite defaults to read-only; PostgreSQL is editable unless --readonly is specified) [SERVERLESS / ADMINDB_SERVERLESS]',
         '      --auth                     Enable authentication (default: on) [ADMINDB_AUTH=true]',
         '      --no-auth, --disable-auth  Disable authentication completely [ADMINDB_NO_AUTH=1 / ADMINDB_AUTH=false]',
         '  -u, --username, --user <user>  Admin username (default: admin) [ADMINDB_USERNAME / ADMINDB_USER]',
@@ -122,8 +122,10 @@ function parseArgs(argv) {
                         args.host = fileConf.host;
                     if (fileConf.basePath !== undefined)
                         args.basePath = fileConf.basePath;
-                    if (fileConf.readonly !== undefined)
+                    if (fileConf.readonly !== undefined) {
                         args.readonly = fileConf.readonly;
+                        args.explicitReadonly = fileConf.readonly;
+                    }
                     if (fileConf.serverless !== undefined)
                         args.serverless = fileConf.serverless;
                     if (fileConf.logLevel !== undefined)
@@ -204,10 +206,10 @@ function parseArgs(argv) {
         }
         else if (tok === '-r' || tok === '--readonly' || tok === '--read-only') {
             args.readonly = true;
+            args.explicitReadonly = true;
         }
         else if (tok === '--serverless') {
             args.serverless = true;
-            args.readonly = true;
         }
         else if (tok === '--no-auth' || tok === '--disable-auth') {
             args.auth = false;

package/dist/cli/config.d.ts

@@ -1 +1 @@
-import type {LogLevel} from '../utils/logger';export interface DatabaseConfigFile{connections?:Record<string,string>;connection?:string;port?:number;host?:string;basePath?:string;readonly ?:boolean;serverless?:boolean;auth?:boolean|{username?:string;password?:string;secret?:string;};logLevel?:LogLevel;}export declare function parseConfigFile(filePath:string):DatabaseConfigFile|null;export interface Config{host:string;port:number;dbPath:string;connection?:string;connections?:Record<string,string>;dbDir?:string;dbFiles?:string[];basePath:string;logLevel:LogLevel;readonly :boolean;serverless:boolean;auth:boolean;authUsername?:string;authPassword?:string;authSecret?:string;}export declare function loadConfig(env?:NodeJS.ProcessEnv):Config;
+import type {LogLevel} from '../utils/logger';export interface DatabaseConfigFile{connections?:Record<string,string>;connection?:string;port?:number;host?:string;basePath?:string;readonly ?:boolean;serverless?:boolean;auth?:boolean|{username?:string;password?:string;secret?:string;};logLevel?:LogLevel;}export declare function parseConfigFile(filePath:string):DatabaseConfigFile|null;export interface Config{host:string;port:number;dbPath:string;connection?:string;connections?:Record<string,string>;dbDir?:string;dbFiles?:string[];basePath:string;logLevel:LogLevel;readonly :boolean;explicitReadonly?:boolean;serverless:boolean;auth:boolean;authUsername?:string;authPassword?:string;authSecret?:string;}export declare function loadConfig(env?:NodeJS.ProcessEnv):Config;

package/dist/cli/config.js

@@ -79,8 +79,14 @@ function loadConfig(env = process.env) {
     const serverlessRaw = env.ADMINDB_SERVERLESS ?? env.SERVERLESS ?? env.IS_SERVERLESS ?? '';
     const serverless = ['1', 'true', 'yes', 'on'].includes(String(serverlessRaw).trim().toLowerCase()) ||
         (0, serverless_1.isServerlessEnvironment)(env);
-    const readonlyRaw = env.ADMINDB_READONLY ?? env.READONLY ?? '';
-    const readonly = serverless || ['1', 'true', 'yes', 'on'].includes(String(readonlyRaw).trim().toLowerCase());
+    const readonlyRaw = env.ADMINDB_READONLY ?? env.READONLY;
+    const explicitReadonly = readonlyRaw !== undefined && readonlyRaw !== ''
+        ? ['1', 'true', 'yes', 'on'].includes(String(readonlyRaw).trim().toLowerCase())
+        : undefined;
+    const isPg = Boolean((connectionRaw && (0, common_1.isPostgresConnectionString)(connectionRaw)) ||
+        (dbPathRaw && (0, common_1.isPostgresConnectionString)(dbPathRaw)));
+    const defaultReadonly = serverless ? !isPg : false;
+    const readonly = explicitReadonly !== undefined ? explicitReadonly : defaultReadonly;
     let connections;
     const configJsonRaw = env.ADMINDB_CONFIG_JSON ?? env.ADMINDB_CONNECTIONS;
     if (configJsonRaw) {
@@ -109,6 +115,7 @@ function loadConfig(env = process.env) {
         basePath: String(basePathRaw).replace(/\/+$/, ''),
         logLevel: logLevelRaw,
         readonly,
+        explicitReadonly,
         serverless,
         auth: !authDisabled,
         authUsername: (env.ADMINDB_USERNAME ?? env.ADMINDB_USER) ? String(env.ADMINDB_USERNAME ?? env.ADMINDB_USER).trim() : undefined,

package/dist/cli/runner.js

@@ -38,9 +38,13 @@ function runCli() {
     const authPassword = args.authPassword ?? env.authPassword;
     const authSecret = args.authSecret ?? env.authSecret;
     const serverless = args.serverless !== undefined ? args.serverless : env.serverless;
-    const readonly = serverless || args.readonly || env.readonly;
+    const explicitReadonly = args.explicitReadonly !== undefined ? args.explicitReadonly : env.explicitReadonly;
     const connections = args.connections ?? env.connections;
     const hasConnections = Boolean(connections && Object.keys(connections).length > 0);
+    const explicitFile = args.connection || args.dbPath || env.connection || env.dbPath;
+    const isPg = Boolean(explicitFile && (0, common_1.isPostgresConnectionString)(explicitFile));
+    const defaultReadonly = serverless ? !isPg : false;
+    const readonly = explicitReadonly !== undefined ? explicitReadonly : defaultReadonly;
     const config = {
         host: args.host ?? env.host,
         port: args.port ?? env.port,
@@ -52,6 +56,7 @@ function runCli() {
         basePath: (args.basePath ?? env.basePath).replace(/\/+$/, ''),
         logLevel: args.logLevel ?? env.logLevel,
         readonly,
+        explicitReadonly,
         serverless,
         auth: authEnabled
             ? {
@@ -67,8 +72,6 @@ function runCli() {
     app.disable('x-powered-by');
     const hasDir = Boolean(config.dbDir);
     const hasFiles = Boolean(config.dbFiles?.length);
-    const explicitFile = args.connection || args.dbPath || config.connection || config.dbPath;
-    const isPg = Boolean(explicitFile && (0, common_1.isPostgresConnectionString)(explicitFile));
     const singleFileOnly = !hasConnections && (Boolean(explicitFile) || isPg) && !hasDir && !hasFiles;
     const useManager = !singleFileOnly;
     const managerFiles = [...(config.dbFiles ?? [])];
@@ -79,10 +82,10 @@ function runCli() {
     const browseRoot = hasDir ? node_path_1.default.resolve(config.dbDir) : undefined;
     const router = useManager
         ? (0, app_1.createRouter)({
-            manager: new manager_1.DbManager({ dir: managerDir, files: managerFiles, connections, readonly: config.readonly }, logger),
+            manager: new manager_1.DbManager({ dir: managerDir, files: managerFiles, connections, readonly: explicitReadonly, serverless: config.serverless }, logger),
             basePath: config.basePath,
             logger,
-            readonly: config.readonly,
+            readonly: explicitReadonly,
             serverless: config.serverless,
             allowBrowse,
             browseRoot,
@@ -93,7 +96,7 @@ function runCli() {
             connection: explicitFile,
             basePath: config.basePath,
             logger,
-            readonly: config.readonly,
+            readonly: explicitReadonly !== undefined ? explicitReadonly : (!isPg && config.serverless),
             serverless: config.serverless,
             auth: config.auth,
         });

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;}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 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';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;}

package/dist/db/manager.js

@@ -10,12 +10,14 @@ const database_1 = require("./database");
 const postgres_1 = require("./postgres");
 const logger_1 = require("../utils/logger");
 const common_1 = require("../utils/common");
+const serverless_1 = require("../serverless");
 const DB_EXTENSIONS = ['.db', '.sqlite', '.sqlite3'];
 class DbManager {
     logger;
     dir;
     createDir;
     readonlyMode;
+    isServerless;
     files = [];
     idByPath = new Map();
     pathById = new Map();
@@ -28,6 +30,7 @@ class DbManager {
         this.dir = opts.dir ? node_path_1.default.resolve(opts.dir) : undefined;
         this.createDir = this.dir ?? process.cwd();
         this.readonlyMode = Boolean(opts.readonly);
+        this.isServerless = opts.serverless !== undefined ? opts.serverless : (0, serverless_1.isServerlessEnvironment)();
         if (this.dir)
             (0, node_fs_1.mkdirSync)(this.dir, { recursive: true });
         if (opts.connections)
@@ -157,12 +160,28 @@ class DbManager {
         return this.pathById.has(id);
     }
     isDbReadOnly(id) {
-        return this.readonlyMode || (this.readonlyById.get(id) ?? false);
+        if (this.readonlyMode)
+            return true;
+        if (this.readonlyById.has(id))
+            return Boolean(this.readonlyById.get(id));
+        if (this.isServerless) {
+            const target = this.pathById.get(id);
+            const isPg = target ? (0, common_1.isPostgresConnectionString)(target) : false;
+            return !isPg;
+        }
+        return false;
     }
     setReadonly(id, readonly) {
         if (this.readonlyMode && !readonly) {
             throw new Error('Manager is in global read-only mode — databases cannot be made writable.');
         }
+        if (this.isServerless && !readonly) {
+            const target = this.pathById.get(id);
+            const isPg = target ? (0, common_1.isPostgresConnectionString)(target) : false;
+            if (!isPg) {
+                throw new Error('SQLite database cannot be made writable in a serverless environment.');
+            }
+        }
         if (this.readonlyById.get(id) === readonly)
             return;
         this.readonlyById.set(id, readonly);
@@ -179,7 +198,7 @@ class DbManager {
         const target = this.pathById.get(id);
         if (!target)
             throw new Error(`Database "${id}" is not registered.`);
-        const isRo = this.readonlyMode || (readonlyOverride !== undefined ? readonlyOverride : (this.readonlyById.get(id) ?? false));
+        const isRo = readonlyOverride !== undefined ? readonlyOverride : this.isDbReadOnly(id);
         let db = this.openDbs.get(id);
         if (db && db.isReadOnly !== isRo) {
             try {

package/dist/serverless.js

@@ -19,30 +19,42 @@ function isServerlessEnvironment(env = process.env) {
         env.CF_PAGES);
 }
 function createServerlessHandler(options = {}) {
-    const rawTarget = options.connection || options.dbPath || '';
+    const envTarget = process.env.ADMINDB_CONNECTION ||
+        process.env.DATABASE_URL ||
+        process.env.POSTGRES_URL ||
+        process.env.PG_CONNECTION ||
+        '';
+    const rawTarget = options.connection || options.dbPath || ((0, common_1.isPostgresConnectionString)(envTarget) ? envTarget : '');
     const isPg = Boolean(options.pgOptions) ||
         (0, common_1.isPostgresConnectionString)(rawTarget) ||
         options.db?.dialect === 'postgres';
     const defaultReadonly = !isPg;
     const app = (0, app_1.createRouter)({
         ...options,
+        connection: options.connection || ((0, common_1.isPostgresConnectionString)(rawTarget) ? rawTarget : undefined),
         serverless: options.serverless ?? true,
-        readonly: options.readonly ?? defaultReadonly,
+        readonly: options.readonly !== undefined ? Boolean(options.readonly) : defaultReadonly,
     });
     return (req, res) => {
         app(req, res);
     };
 }
 function createLambdaHandler(options = {}) {
-    const rawTarget = options.connection || options.dbPath || '';
+    const envTarget = process.env.ADMINDB_CONNECTION ||
+        process.env.DATABASE_URL ||
+        process.env.POSTGRES_URL ||
+        process.env.PG_CONNECTION ||
+        '';
+    const rawTarget = options.connection || options.dbPath || ((0, common_1.isPostgresConnectionString)(envTarget) ? envTarget : '');
     const isPg = Boolean(options.pgOptions) ||
         (0, common_1.isPostgresConnectionString)(rawTarget) ||
         options.db?.dialect === 'postgres';
     const defaultReadonly = !isPg;
     const app = (0, app_1.createRouter)({
         ...options,
+        connection: options.connection || ((0, common_1.isPostgresConnectionString)(rawTarget) ? rawTarget : undefined),
         serverless: options.serverless ?? true,
-        readonly: options.readonly ?? defaultReadonly,
+        readonly: options.readonly !== undefined ? Boolean(options.readonly) : defaultReadonly,
     });
     return async (event, _context) => {
         return new Promise((resolve) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "admindb",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Browser-based SQLite & PostgreSQL database administration tool — embed it in your Express app or run it standalone.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,7 +15,8 @@
     "generatehash": "node scripts/generate-hash.mjs",
     "screenshots": "npm run build && node scripts/capture-screenshots.mjs",
     "lint": "tsc --noEmit",
-    "testapp": "node testapp/server.js"
+    "testapp": "node testapp/server.js",
+    "publish": "node scripts/publish.js"
   },
   "dependencies": {
     "better-sqlite3": "^11.9.1",