admindb 2.1.0 → 2.2.1

package/dist/routes/databases.d.ts

@@ -1,26 +1 @@
-import type { Router } from 'express';
-import type { DbManager, DatabaseEntry } from '../db/manager';
-import type { Logger } from '../utils/logger';
-interface DatabasesContext {
-    manager: DbManager;
-    logger: Logger;
-    basePath: string;
-    readonly?: boolean;
-    allowBrowse?: boolean;
-    browseRoot?: string;
-    invalidate?: (id: string) => void;
-}
-export interface DatabaseRow extends DatabaseEntry {
-    sizeLabel: string;
-    modifiedLabel: string;
-    tables: number;
-}
-export interface FsEntry {
-    name: string;
-    path: string;
-    isDir: boolean;
-    isDb: boolean;
-    size: number;
-}
-export declare function registerDatabasesRoutes(router: Router, ctx: DatabasesContext): void;
-export {};
+import type {Router} from 'express';import type {DbManager,DatabaseEntry} from '../db/manager';import type {Logger} from '../utils/logger';interface DatabasesContext{manager:DbManager;logger:Logger;basePath:string;readonly ?:boolean;allowBrowse?:boolean;browseRoot?:string;invalidate?:(id:string)=>void;}export interface DatabaseRow extends DatabaseEntry{sizeLabel:string;modifiedLabel:string;tables:number;}export interface FsEntry{name:string;path:string;isDir:boolean;isDb:boolean;size:number;}export declare function registerDatabasesRoutes(router:Router,ctx:DatabasesContext):void;export{};

package/dist/routes/databases.js

@@ -162,13 +162,12 @@ function registerDatabasesRoutes(router, ctx) {
         if (!connectionString) {
             return res.status(400).json({ success: false, error: 'PostgreSQL connection string is required (e.g. postgresql://user:password@localhost:5432/dbname).' });
         }
-        if (!connectionString.startsWith('postgres://') && !connectionString.startsWith('postgresql://')) {
+        if (!(0, common_1.isPostgresConnectionString)(connectionString)) {
             return res.status(400).json({ success: false, error: 'Invalid connection protocol. Connection string must start with postgres:// or postgresql://' });
         }
         let id;
         try {
             id = manager.addConnection(name, connectionString, isRo);
-            // Verify the connection works
             const db = manager.open(id);
             await db.listTables();
         }
@@ -227,4 +226,3 @@ function registerDatabasesRoutes(router, ctx) {
         res.json({ success: true, data: { message: `Database "${id}" removed.` } });
     }));
 }
-//# sourceMappingURL=databases.js.map

package/dist/routes/index.d.ts

@@ -1,3 +1 @@
-export * from './pages';
-export * from './databases';
-export * from './api/index';
+export * from './pages';export * from './databases';export * from './api/index';

package/dist/routes/index.js

@@ -17,4 +17,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./pages"), exports);
 __exportStar(require("./databases"), exports);
 __exportStar(require("./api/index"), exports);
-//# sourceMappingURL=index.js.map

package/dist/routes/pages.d.ts

@@ -1,9 +1 @@
-import type { Router } from 'express';
-import type { IDatabase } from '../db/index';
-import type { Logger } from '../utils/logger';
-interface PageContext {
-    db: IDatabase;
-    logger: Logger;
-}
-export declare function registerPages(router: Router, ctx: PageContext): void;
-export {};
+import type {Router} from 'express';import type {IDatabase} from '../db/index';import type {Logger} from '../utils/logger';interface PageContext{db:IDatabase;logger:Logger;}export declare function registerPages(router:Router,ctx:PageContext):void;export{};

package/dist/routes/pages.js

@@ -88,7 +88,6 @@ function registerPages(router, ctx) {
     const notFound = (res, message) => {
         res.status(404).render('pages/error', { title: 'Not found', status: 404, error: message });
     };
-    // Home / browse overview.
     router.get('/', async (_req, res, next) => {
         try {
             const names = res.locals.tables ?? [];
@@ -141,7 +140,6 @@ function registerPages(router, ctx) {
             next(err);
         }
     });
-    // Browse a table's rows.
     router.get('/tables/:table', async (req, res, next) => {
         try {
             const table = req.params.table;
@@ -184,7 +182,6 @@ function registerPages(router, ctx) {
                 const ref = rt.refs[0];
                 return { table: rt.table, from: ref?.from ?? '', to: ref?.to ?? '' };
             });
-            // Per-row reference counts: parallel query per referencing table.
             const countEntries = await Promise.all(refColumns.map(async (col) => {
                 const values = rawRows
                     .map((r) => r[col.to])
@@ -248,7 +245,6 @@ function registerPages(router, ctx) {
             next(err);
         }
     });
-    // Table schema editor.
     router.get('/tables/:table/schema', async (req, res, next) => {
         try {
             const table = req.params.table;
@@ -275,7 +271,6 @@ function registerPages(router, ctx) {
             next(err);
         }
     });
-    // Data generator / seeder.
     router.get('/tables/:table/seed', async (req, res, next) => {
         try {
             const table = req.params.table;
@@ -300,7 +295,6 @@ function registerPages(router, ctx) {
             next(err);
         }
     });
-    // Insert form.
     router.get('/tables/:table/rows/new', async (req, res, next) => {
         try {
             const table = req.params.table;
@@ -324,7 +318,6 @@ function registerPages(router, ctx) {
             next(err);
         }
     });
-    // Edit form.
     router.get('/tables/:table/rows/:id/edit', async (req, res, next) => {
         try {
             const table = req.params.table;
@@ -352,7 +345,9 @@ function registerPages(router, ctx) {
             next(err);
         }
     });
-    // Table designer.
+    router.get('/erd', (_req, res) => {
+        res.render('pages/erd', { title: 'ER Diagram' });
+    });
     router.get('/designer', (_req, res) => {
         res.render('pages/designer', {
             title: 'New table',
@@ -361,7 +356,6 @@ function registerPages(router, ctx) {
             isPostgres: db.dialect === 'postgres',
         });
     });
-    // Query editor.
     router.get('/query', async (_req, res, next) => {
         try {
             const queries = await db.listSavedQueries();
@@ -371,7 +365,6 @@ function registerPages(router, ctx) {
             next(err);
         }
     });
-    // Export: downloadable SQL dump.
     router.get('/export', async (_req, res, next) => {
         try {
             const dump = await (0, export_1.generateSqlDump)(db);
@@ -386,5 +379,19 @@ function registerPages(router, ctx) {
             next(err);
         }
     });
+    router.get('/info', async (_req, res, next) => {
+        try {
+            const settingsRes = await db.getSettings();
+            const settings = settingsRes.success ? settingsRes.data : {};
+            res.render('pages/info', {
+                title: 'Database Info',
+                settings,
+                dialect: db.dialect,
+                dbPath: db.path,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
 }
-//# sourceMappingURL=pages.js.map

package/dist/serverless.d.ts

@@ -1,40 +1 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
-import { type AppOptions } from './app';
-/**
- * Detects if the current process is running in a serverless environment
- * (e.g. Vercel, AWS Lambda, Netlify Functions, Google Cloud Functions/Run, Azure Functions, Cloudflare Pages).
- */
-export declare function isServerlessEnvironment(env?: NodeJS.ProcessEnv): boolean;
-/**
- * Creates an HTTP request listener for standard Node.js serverless runtimes
- * (Vercel API routes, Next.js custom route handlers, Google Cloud Functions, Azure Functions, Micro).
- *
- * In serverless mode, all write operations and database mutations are strictly disabled.
- *
- * Example (Vercel `api/index.ts`):
- * ```ts
- * import { createServerlessHandler } from 'admindb';
- * export default createServerlessHandler({ dbPath: './data.db' });
- * ```
- */
-export declare function createServerlessHandler(options?: AppOptions): (req: IncomingMessage, res: ServerResponse) => void;
-export interface LambdaProxyResult {
-    statusCode: number;
-    headers: Record<string, string>;
-    multiValueHeaders?: Record<string, string[]>;
-    body: string;
-    isBase64Encoded: boolean;
-}
-/**
- * Creates an AWS Lambda handler for API Gateway (REST v1 and HTTP v2 payloads).
- *
- * In serverless mode, SQLite databases are read-only, while remote PostgreSQL
- * connections are editable unless configured otherwise.
- *
- * Example (AWS Lambda `index.ts`):
- * ```ts
- * import { createLambdaHandler } from 'admindb';
- * export const handler = createLambdaHandler({ dbPath: './data.db' });
- * ```
- */
-export declare function createLambdaHandler(options?: AppOptions): (event: any, _context?: any) => Promise<LambdaProxyResult>;
+import{IncomingMessage,ServerResponse} from 'node:http';import{type AppOptions} from './app';export declare function isServerlessEnvironment(env?:NodeJS.ProcessEnv):boolean;export declare function createServerlessHandler(options?:AppOptions):(req:IncomingMessage,res:ServerResponse)=>void;export interface LambdaProxyResult{statusCode:number;headers:Record<string,string>;multiValueHeaders?:Record<string,string[]>;body:string;isBase64Encoded:boolean;}export declare function createLambdaHandler(options?:AppOptions):(event:any,_context?:any)=>Promise<LambdaProxyResult>;

package/dist/serverless.js

@@ -6,57 +6,35 @@ exports.createLambdaHandler = createLambdaHandler;
 const node_http_1 = require("node:http");
 const node_net_1 = require("node:net");
 const app_1 = require("./app");
-/**
- * Detects if the current process is running in a serverless environment
- * (e.g. Vercel, AWS Lambda, Netlify Functions, Google Cloud Functions/Run, Azure Functions, Cloudflare Pages).
- */
+const common_1 = require("./utils/common");
 function isServerlessEnvironment(env = process.env) {
-    // Explicit serverless flags
     if (['1', 'true', 'yes', 'on'].includes(String(env.ADMINDB_SERVERLESS ?? env.SERVERLESS ?? env.IS_SERVERLESS ?? '').trim().toLowerCase())) {
         return true;
     }
-    // Vercel Serverless Functions
     if (Boolean(env.VERCEL || env.VERCEL_ENV || env.NOW_REGION)) {
         return true;
     }
-    // AWS Lambda
     if (Boolean(env.AWS_LAMBDA_FUNCTION_NAME || env.LAMBDA_TASK_ROOT || env.AWS_EXECUTION_ENV)) {
         return true;
     }
-    // Netlify Functions
     if (Boolean(env.NETLIFY || env.NETLIFY_LOCAL)) {
         return true;
     }
-    // Google Cloud Functions / Cloud Run
     if (Boolean(env.FUNCTION_TARGET || env.FUNCTION_NAME || env.K_SERVICE)) {
         return true;
     }
-    // Azure Functions
     if (Boolean(env.FUNCTIONS_WORKER_RUNTIME || env.WEBSITE_INSTANCE_ID)) {
         return true;
     }
-    // Cloudflare Pages
     if (Boolean(env.CF_PAGES)) {
         return true;
     }
     return false;
 }
-/**
- * Creates an HTTP request listener for standard Node.js serverless runtimes
- * (Vercel API routes, Next.js custom route handlers, Google Cloud Functions, Azure Functions, Micro).
- *
- * In serverless mode, all write operations and database mutations are strictly disabled.
- *
- * Example (Vercel `api/index.ts`):
- * ```ts
- * import { createServerlessHandler } from 'admindb';
- * export default createServerlessHandler({ dbPath: './data.db' });
- * ```
- */
 function createServerlessHandler(options = {}) {
     const rawTarget = options.connection || options.dbPath || '';
     const isPg = Boolean(options.pgOptions) ||
-        (typeof rawTarget === 'string' && (rawTarget.startsWith('postgres://') || rawTarget.startsWith('postgresql://'))) ||
+        (0, common_1.isPostgresConnectionString)(rawTarget) ||
         options.db?.dialect === 'postgres';
     const defaultReadonly = isPg ? false : true;
     const app = (0, app_1.createRouter)({
@@ -68,22 +46,10 @@ function createServerlessHandler(options = {}) {
         app(req, res);
     };
 }
-/**
- * Creates an AWS Lambda handler for API Gateway (REST v1 and HTTP v2 payloads).
- *
- * In serverless mode, SQLite databases are read-only, while remote PostgreSQL
- * connections are editable unless configured otherwise.
- *
- * Example (AWS Lambda `index.ts`):
- * ```ts
- * import { createLambdaHandler } from 'admindb';
- * export const handler = createLambdaHandler({ dbPath: './data.db' });
- * ```
- */
 function createLambdaHandler(options = {}) {
     const rawTarget = options.connection || options.dbPath || '';
     const isPg = Boolean(options.pgOptions) ||
-        (typeof rawTarget === 'string' && (rawTarget.startsWith('postgres://') || rawTarget.startsWith('postgresql://'))) ||
+        (0, common_1.isPostgresConnectionString)(rawTarget) ||
         options.db?.dialect === 'postgres';
     const defaultReadonly = isPg ? false : true;
     const app = (0, app_1.createRouter)({
@@ -117,7 +83,6 @@ function createLambdaHandler(options = {}) {
                 if (event.cookies && Array.isArray(event.cookies) && !headers['cookie']) {
                     headers['cookie'] = event.cookies.join('; ');
                 }
-                // Prepare request body
                 let bodyBuffer = null;
                 if (event.body) {
                     if (event.isBase64Encoded) {
@@ -207,4 +172,3 @@ function createLambdaHandler(options = {}) {
         });
     };
 }
-//# sourceMappingURL=serverless.js.map

package/dist/sql/classifier.d.ts

@@ -1,19 +1 @@
-/**
- * Classify incoming SQL as a read (SELECT), a count query, or a write
- * statement, so the query runner can decide how to render/execute it.
- */
-export type SqlKind = 'select' | 'count' | 'read' | 'write';
-/** Extract the first keyword, skipping leading whitespace and comments. */
-export declare function firstKeyword(sql: string): string;
-export interface Classification {
-    kind: SqlKind;
-    keyword: string;
-}
-/**
- * Classify a SQL statement.
- * - SELECT / WITH → `select`, unless it is a pure `count(...)` (no GROUP BY)
- *   in which case it is `count`.
- * - INSERT / UPDATE / DELETE / REPLACE / CREATE / DROP / ALTER → `write`.
- * - Anything else that may still return rows (PRAGMA, EXPLAIN, …) → `read`.
- */
-export declare function classifySql(sql: string): Classification;
+export type SqlKind='select'|'count'|'read'|'write';export declare function firstKeyword(sql:string):string;export interface Classification{kind:SqlKind;keyword:string;}export declare function classifySql(sql:string):Classification;

package/dist/sql/classifier.js

@@ -1,25 +1,13 @@
 "use strict";
-/**
- * Classify incoming SQL as a read (SELECT), a count query, or a write
- * statement, so the query runner can decide how to render/execute it.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.firstKeyword = firstKeyword;
 exports.classifySql = classifySql;
 const LEADING_NOISE = /^\s*((\/\*[\s\S]*?\*\/)|(--[^\n]*\n))*\s*/;
-/** Extract the first keyword, skipping leading whitespace and comments. */
 function firstKeyword(sql) {
     const cleaned = String(sql).replace(LEADING_NOISE, '').trim();
     const m = cleaned.match(/^([a-zA-Z]+)/);
     return m ? m[1].toUpperCase() : '';
 }
-/**
- * Classify a SQL statement.
- * - SELECT / WITH → `select`, unless it is a pure `count(...)` (no GROUP BY)
- *   in which case it is `count`.
- * - INSERT / UPDATE / DELETE / REPLACE / CREATE / DROP / ALTER → `write`.
- * - Anything else that may still return rows (PRAGMA, EXPLAIN, …) → `read`.
- */
 function classifySql(sql) {
     const keyword = firstKeyword(sql);
     if (keyword === 'SELECT' || keyword === 'WITH') {
@@ -34,4 +22,3 @@ function classifySql(sql) {
     }
     return { kind: 'read', keyword: keyword || 'UNKNOWN' };
 }
-//# sourceMappingURL=classifier.js.map

package/dist/sql/error-analyzer.d.ts

@@ -0,0 +1 @@
+import type {IDatabase} from '../db/types';export interface SqlErrorDetails{message:string;line?:number;column?:number;token?:string;snippet?:string;cause?:string;suggestion?:string;raw?:string;}export declare function buildErrorSnippet(sql:string,line:number,column:number):string;export declare function offsetToLineCol(sql:string,offset:number):{line:number;column:number;};export declare function maskCommentsAndStrings(sql:string):string;export declare function findTokenPosition(sql:string,token:string):{line:number;column:number;}|null;export declare function analyzeSqlError(sql:string,rawError:unknown,db?:IDatabase):Promise<SqlErrorDetails>;