admindb 2.3.0 → 2.4.0

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.
 
@@ -309,22 +309,22 @@ ADMINDB_AUTH=false npx admindb
 AdminDB exposes a comprehensive REST API under `basePath` returning `{ success, data?, error? }`:
 
 ```text
-GET    /api/tables                                 List tables
-GET    /api/tables/:table/rows                     Paginated rows (with filtering & sorting)
-GET    /api/tables/:table/row/:id                  Get a single row
-GET    /api/tables/:table/row/:id/blob/:column     Stream raw BLOB / BYTEA binary data
-GET    /api/tables/:table/row/:id/blob/:col/meta   BLOB / BYTEA metadata, MIME analysis & hex dump
-PUT    /api/tables/:table/row/:id/blob/:column     Upload / update binary content
-POST   /api/tables/:table/rows                     Insert row (single or batch)
-PUT    /api/tables/:table/row/:id                  Update row
-DELETE /api/tables/:table/row/:id                  Delete row
-POST   /api/tables/:table/rows/bulk-update         Apply staged inline edits atomically
-POST   /api/tables/:table/rows/bulk-delete         Delete selected rows atomically
-POST   /api/tables/:table/seed                     Generate & insert realistic seed rows
-POST   /api/tables                                 Create a new table
-GET    /api/tables/:table/schema                   Inspect table schema & constraints
-GET    /api/tables/:table/ddl                      Get table CREATE SQL & indexes
-POST   /api/query                                  Execute arbitrary SQL
+GET    /api/tables/:db                             List tables
+GET    /api/tables/:db/:table/rows                 Paginated rows (with filtering & sorting)
+GET    /api/tables/:db/:table/row/:id              Get a single row
+GET    /api/tables/:db/:table/row/:id/blob/:column Stream raw BLOB / BYTEA binary data
+GET    /api/tables/:db/:table/row/:id/blob/:col/meta BLOB / BYTEA metadata, MIME analysis & hex dump
+PUT    /api/tables/:db/:table/row/:id/blob/:column Upload / update binary content
+POST   /api/tables/:db/:table/rows                 Insert row (single or batch)
+PUT    /api/tables/:db/:table/row/:id              Update row
+DELETE /api/tables/:db/:table/row/:id              Delete row
+POST   /api/tables/:db/:table/rows/bulk-update     Apply staged inline edits atomically
+POST   /api/tables/:db/:table/rows/bulk-delete     Delete selected rows atomically
+POST   /api/tables/:db/:table/seed                 Generate & insert realistic seed rows
+POST   /api/tables/:db                             Create a new table
+GET    /api/tables/:db/:table/schema               Inspect table schema & constraints
+GET    /api/tables/:db/:table/ddl                  Get table CREATE SQL & indexes
+POST   /api/query/:db                              Execute arbitrary SQL
 GET    /api/databases                              List managed database connections & files
 ```
 

package/dist/app.js

@@ -20,7 +20,120 @@ const serverless_1 = require("./serverless");
 const auth_1 = require("./auth");
 const APP_VERSION = (0, args_1.getPackageVersion)();
 function createRouter(options = {}) {
-    return options.manager ? createManagerApp(options) : createSingleDbApp(options);
+    const isServerless = options.serverless !== undefined ? options.serverless : (0, serverless_1.isServerlessEnvironment)();
+    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);
+    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 explicitReadonly = options.readonly !== undefined ? Boolean(options.readonly) : undefined;
+    const globalReadonly = explicitReadonly !== undefined
+        ? explicitReadonly
+        : options.manager
+            ? options.manager.isReadOnly
+            : isServerless
+                ? !isPg
+                : false;
+    const manager = options.manager;
+    let singleDb;
+    let defaultDbId = options.dbId;
+    if (!manager) {
+        if (options.db) {
+            singleDb = options.db;
+            if (options.readonly !== undefined && singleDb.isReadOnly !== Boolean(options.readonly)) {
+                try {
+                    Object.defineProperty(singleDb, 'isReadOnly', { value: Boolean(options.readonly), configurable: true });
+                }
+                catch { }
+            }
+        }
+        else if (isPg) {
+            singleDb = new postgres_1.PostgresDatabase(options.pgOptions || rawTarget, logger, { readonly: globalReadonly });
+        }
+        else {
+            singleDb = new database_1.SqliteDatabase(options.dbPath ?? 'admindb.db', logger, { readonly: globalReadonly });
+        }
+        if (!defaultDbId) {
+            defaultDbId = singleDb.dialect === 'postgres' ? 'PostgreSQL' : (node_path_1.default.basename(singleDb.path) || 'SQLite');
+        }
+    }
+    const app = (0, express_1.default)();
+    app.disable('x-powered-by');
+    app.use(express_1.default.static(node_path_1.default.join(__dirname, 'public')));
+    setupViewEngine(app, logger);
+    app.use(express_1.default.json({ limit: '10mb' }));
+    app.use(express_1.default.urlencoded({ extended: false }));
+    (0, auth_1.registerAuthRoutes)(app, authConfig, basePath, logger);
+    app.use((0, auth_1.createAuthMiddleware)(authConfig, basePath, logger));
+    app.use(async (req, res, next) => {
+        try {
+            res.locals.basePath = basePath;
+            res.locals.currentPath = req.path;
+            res.locals.currentTable = null;
+            res.locals.dbPath = manager ? manager.directory : singleDb?.path;
+            res.locals.dbId = defaultDbId ?? null;
+            res.locals.databasesUrl = manager ? `${basePath}/` : (options.databasesUrl ?? null);
+            res.locals.databasesMode = false;
+            res.locals.readonly = globalReadonly;
+            res.locals.serverless = isServerless;
+            res.locals.version = APP_VERSION;
+            res.locals.authEnabled = authConfig.enabled;
+            res.locals.isDefaultPassword = authConfig.isDefaultPassword;
+            res.locals.icons = icons_1.ICONS;
+            res.locals.tables = [];
+            res.locals.internalTables = [];
+            next();
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    const getDb = (req) => {
+        if (manager) {
+            const dbId = String(req.params.db || req.params.dbId || req.params.id || '');
+            if (!manager.has(dbId)) {
+                const err = new Error(`Database "${dbId}" does not exist.`);
+                err.status = 404;
+                throw err;
+            }
+            const rawRo = req.query.readonly;
+            if (rawRo !== undefined) {
+                const explicitRo = rawRo === '1' || rawRo === 'true';
+                if (!globalReadonly || explicitRo) {
+                    manager.setReadonly(dbId, explicitRo);
+                }
+            }
+            const effectiveRo = globalReadonly ? true : manager.isDbReadOnly(dbId);
+            return manager.open(dbId, effectiveRo);
+        }
+        return singleDb;
+    };
+    if (manager) {
+        (0, databases_1.registerDatabasesRoutes)(app, {
+            manager,
+            logger,
+            basePath,
+            readonly: globalReadonly,
+            allowBrowse: isServerless ? false : options.allowBrowse,
+            browseRoot: options.browseRoot,
+        });
+    }
+    else {
+        app.get('/', (_req, res) => {
+            res.redirect(302, `${basePath}/home/${encodeURIComponent(defaultDbId)}`);
+        });
+    }
+    (0, pages_1.registerPages)(app, { getDb, logger });
+    (0, index_1.registerApi)(app, { getDb, logger });
+    addErrorHandlers(app, logger);
+    return app;
 }
 function setupViewEngine(app, _logger) {
     app.engine('hbs', (0, express_handlebars_1.engine)({
@@ -42,6 +155,9 @@ function setupViewEngine(app, _logger) {
             gt: (a, b) => Number(a) > Number(b),
             lt: (a, b) => Number(a) < Number(b),
             join: (arr, sep) => (Array.isArray(arr) ? arr.join(String(sep ?? ',')) : String(arr ?? '')),
+            encodeUri: (str) => encodeURIComponent(String(str ?? '')),
+            or: (a, b) => a || b,
+            tableName: (t) => (typeof t === 'object' && t !== null && 'name' in t ? String(t.name ?? '') : String(t ?? '')),
             icon: (name, options) => {
                 const customClass = (options && options.hash && options.hash.class) || undefined;
                 return (0, icons_1.renderIcon)(String(name ?? ''), customClass);
@@ -59,169 +175,13 @@ function addErrorHandlers(app, logger) {
         res.status(404).render('pages/error', { title: 'Not found', status: 404, error: 'The page you requested does not exist.' });
     });
     app.use((err, req, res, _next) => {
-        logger.error('Unhandled error', err);
-        if (req.path.startsWith('/api/')) {
-            return res.status(500).json({ success: false, error: (0, common_1.errorMessage)(err) });
+        const status = typeof err?.status === 'number' ? err.status : 500;
+        if (status >= 500) {
+            logger.error('Unhandled error', err);
         }
-        res.status(500).render('pages/error', { title: 'Error', status: 500, error: (0, common_1.errorMessage)(err) });
-    });
-}
-function createSingleDbApp(options) {
-    const isServerless = options.serverless !== undefined ? options.serverless : (0, serverless_1.isServerlessEnvironment)();
-    const rawTarget = options.connection || options.dbPath || '';
-    const isPg = Boolean(options.pgOptions) ||
-        (0, common_1.isPostgresConnectionString)(rawTarget) ||
-        options.db?.dialect === 'postgres';
-    const readonly = options.readonly !== undefined
-        ? Boolean(options.readonly)
-        : (isServerless && !isPg);
-    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;
-    }
-    else if (isPg) {
-        db = new postgres_1.PostgresDatabase(options.pgOptions || rawTarget, logger, { readonly });
-    }
-    else {
-        db = new database_1.SqliteDatabase(options.dbPath ?? 'admindb.db', logger, { readonly });
-    }
-    const databasesUrl = options.databasesUrl;
-    const authConfig = (0, auth_1.resolveAuthConfig)(options.auth);
-    const router = (0, express_1.default)();
-    router.disable('x-powered-by');
-    router.use(express_1.default.static(node_path_1.default.join(__dirname, 'public')));
-    setupViewEngine(router, logger);
-    router.use(express_1.default.json({ limit: '10mb' }));
-    router.use(express_1.default.urlencoded({ extended: false }));
-    (0, auth_1.registerAuthRoutes)(router, authConfig, basePath, logger);
-    router.use((0, auth_1.createAuthMiddleware)(authConfig, basePath, logger));
-    router.use(async (req, res, next) => {
-        try {
-            res.locals.basePath = basePath;
-            res.locals.currentPath = req.path;
-            res.locals.currentTable = null;
-            res.locals.dbPath = db.path;
-            res.locals.dbId = options.dbId ?? (db.dialect === 'postgres' ? 'PostgreSQL' : (node_path_1.default.basename(db.path) || 'SQLite'));
-            res.locals.dialect = db.dialect;
-            res.locals.isPostgres = db.dialect === 'postgres';
-            res.locals.isSqlite = db.dialect === 'sqlite';
-            res.locals.dialectName = db.dialect === 'postgres' ? 'PostgreSQL' : 'SQLite';
-            res.locals.databasesUrl = databasesUrl ?? null;
-            res.locals.databasesMode = false;
-            res.locals.readonly = db.isReadOnly;
-            res.locals.serverless = isServerless;
-            res.locals.version = APP_VERSION;
-            res.locals.authEnabled = authConfig.enabled;
-            res.locals.isDefaultPassword = authConfig.isDefaultPassword;
-            res.locals.icons = icons_1.ICONS;
-            if (!req.path.startsWith('/api/')) {
-                const all = await db.listTables();
-                const names = (all.data ?? []).map((t) => t.name);
-                res.locals.tables = names.filter((n) => !n.startsWith('_'));
-                res.locals.internalTables = names.filter((n) => n.startsWith('_'));
-            }
-            next();
-        }
-        catch (err) {
-            next(err);
-        }
-    });
-    (0, pages_1.registerPages)(router, { db, logger });
-    (0, index_1.registerApi)(router, { db, logger });
-    addErrorHandlers(router, logger);
-    return router;
-}
-function createManagerApp(options) {
-    const isServerless = options.serverless !== undefined ? options.serverless : (0, serverless_1.isServerlessEnvironment)();
-    const readonly = isServerless || Boolean(options.readonly);
-    const manager = options.manager;
-    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);
-    const app = (0, express_1.default)();
-    app.disable('x-powered-by');
-    app.use(express_1.default.static(node_path_1.default.join(__dirname, 'public')));
-    setupViewEngine(app, logger);
-    app.use(express_1.default.json({ limit: '10mb' }));
-    app.use(express_1.default.urlencoded({ extended: false }));
-    (0, auth_1.registerAuthRoutes)(app, authConfig, basePath, logger);
-    app.use((0, auth_1.createAuthMiddleware)(authConfig, basePath, logger));
-    app.use(async (req, res, next) => {
-        try {
-            res.locals.basePath = basePath;
-            res.locals.currentPath = req.path;
-            res.locals.currentTable = null;
-            res.locals.dbPath = manager.directory;
-            res.locals.dbId = null;
-            res.locals.databasesUrl = null;
-            res.locals.databasesMode = true;
-            res.locals.readonly = readonly;
-            res.locals.serverless = isServerless;
-            res.locals.version = APP_VERSION;
-            res.locals.authEnabled = authConfig.enabled;
-            res.locals.isDefaultPassword = authConfig.isDefaultPassword;
-            res.locals.icons = icons_1.ICONS;
-            if (!req.path.startsWith('/api/')) {
-                res.locals.tables = [];
-                res.locals.internalTables = [];
-            }
-            next();
-        }
-        catch (err) {
-            next(err);
-        }
-    });
-    const subApps = new Map();
-    (0, databases_1.registerDatabasesRoutes)(app, {
-        manager,
-        logger,
-        basePath,
-        readonly,
-        allowBrowse: isServerless ? false : options.allowBrowse,
-        browseRoot: options.browseRoot,
-        invalidate: (id) => subApps.delete(id),
-    });
-    app.use('/:dbId', (req, res, next) => {
-        const dbId = String(req.params.dbId);
-        if (!manager.has(dbId)) {
-            if (req.path.startsWith('/api/')) {
-                return res.status(404).json({ success: false, error: `Database "${dbId}" does not exist.` });
-            }
-            return res.status(404).render('pages/error', {
-                title: 'Not found',
-                status: 404,
-                error: `Database "${dbId}" does not exist.`,
-            });
-        }
-        const rawRo = req.query.readonly;
-        if (rawRo !== undefined) {
-            const explicitRo = rawRo === '1' || rawRo === 'true';
-            if (!readonly || explicitRo) {
-                manager.setReadonly(dbId, explicitRo);
-                subApps.delete(dbId);
-            }
-        }
-        let sub = subApps.get(dbId);
-        if (!sub) {
-            const subBase = `${basePath || ''}/${encodeURIComponent(dbId)}`;
-            const effectiveRo = readonly || manager.isDbReadOnly(dbId);
-            sub = createSingleDbApp({
-                db: manager.open(dbId, effectiveRo),
-                basePath: subBase,
-                logger,
-                logLevel: options.logLevel,
-                dbId,
-                databasesUrl: `${basePath || ''}/`,
-                readonly: effectiveRo,
-                serverless: isServerless,
-                auth: authConfig,
-            });
-            subApps.set(dbId, sub);
+        if (req.path.startsWith('/api/')) {
+            return res.status(status).json({ success: false, error: (0, common_1.errorMessage)(err) });
         }
-        return sub(req, res, next);
+        res.status(status).render('pages/error', { title: status === 404 ? 'Not found' : 'Error', status, error: (0, common_1.errorMessage)(err) });
     });
-    addErrorHandlers(app, logger);
-    return app;
 }

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 {