admindb 2.4.0 → 2.5.0

package/dist/modules/databases/databases.service.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabasesService = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const common_1 = require("../../utils/common");
+const BLOCKED_NAMES = new Set([
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    'System Volume Information',
+    '$RECYCLE.BIN',
+    '.env',
+    '.aws',
+    '.ssh',
+]);
+function formatDate(iso) {
+    try {
+        return new Date(iso).toLocaleString();
+    }
+    catch {
+        return iso;
+    }
+}
+class DatabasesService {
+    static async getDatabaseRows(manager) {
+        const entries = manager.list();
+        return Promise.all(entries.map(async (e) => ({
+            ...e,
+            isPostgres: e.dialect === 'postgres',
+            isSqlite: e.dialect === 'sqlite',
+            sizeLabel: e.dialect === 'postgres' ? 'Remote' : (0, common_1.formatBytes)(e.size),
+            modifiedLabel: e.dialect === 'postgres' ? 'Connected' : (e.modified ? formatDate(e.modified) : '—'),
+            tables: await manager.countTables(e.id),
+        })));
+    }
+    static listDirectory(base, manager, browseRoot) {
+        if (base.includes('\0'))
+            throw new Error('Invalid path.');
+        if (browseRoot && !(0, common_1.isPathWithinRoot)(browseRoot, base)) {
+            throw new Error(`Path is outside the allowed folder: ${browseRoot}`);
+        }
+        if (!(0, node_fs_1.existsSync)(base))
+            throw new Error(`Path does not exist: ${base}`);
+        if (!(0, node_fs_1.statSync)(base).isDirectory())
+            throw new Error(`Not a directory: ${base}`);
+        const entries = [];
+        for (const name of (0, node_fs_1.readdirSync)(base)) {
+            if (name.startsWith('.') || BLOCKED_NAMES.has(name) || name.toLowerCase().startsWith('.env'))
+                continue;
+            const full = node_path_1.default.join(base, name);
+            let isDir = false;
+            let size = 0;
+            try {
+                const st = (0, node_fs_1.statSync)(full);
+                isDir = st.isDirectory();
+                size = isDir ? 0 : st.size;
+            }
+            catch {
+                continue;
+            }
+            if (!isDir && !manager.isDbFile(name))
+                continue;
+            if (browseRoot && !(0, common_1.isPathWithinRoot)(browseRoot, full))
+                continue;
+            entries.push({ name, path: full, isDir, isDb: !isDir, size });
+        }
+        entries.sort((a, b) => a.isDir === b.isDir ? a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }) : a.isDir ? -1 : 1);
+        const parent = node_path_1.default.dirname(base) === base ? null : node_path_1.default.dirname(base);
+        const effectiveParent = parent && (!browseRoot || (0, common_1.isPathWithinRoot)(browseRoot, parent)) ? parent : null;
+        return {
+            path: base,
+            name: node_path_1.default.basename(base) || base,
+            parent: effectiveParent,
+            entries,
+        };
+    }
+    static openDatabaseFile(manager, filePath, isRo, browseRoot) {
+        const p = String(filePath ?? '').trim();
+        if (!p || p.includes('\0'))
+            throw new Error('Valid database path is required.');
+        const abs = node_path_1.default.resolve(p);
+        if (browseRoot && !(0, common_1.isPathWithinRoot)(browseRoot, abs)) {
+            throw new Error(`Cannot open a database outside the allowed folder: ${browseRoot}`);
+        }
+        return manager.openFile(p, isRo);
+    }
+    static async connectPostgres(manager, name, connectionString, isRo) {
+        const conn = String(connectionString ?? '').trim();
+        if (!conn) {
+            throw new Error('PostgreSQL connection string is required (e.g. postgresql://user:password@localhost:5432/dbname).');
+        }
+        if (!(0, common_1.isPostgresConnectionString)(conn)) {
+            throw new Error('Invalid connection protocol. Connection string must start with postgres:// or postgresql://');
+        }
+        let id;
+        try {
+            id = manager.addConnection(name, conn, isRo);
+            const db = manager.open(id);
+            await db.listTables();
+            return id;
+        }
+        catch (err) {
+            if (id)
+                manager.remove(id);
+            throw new Error(`Failed to connect to PostgreSQL: ${(0, common_1.errorMessage)(err)}`);
+        }
+    }
+    static createDatabase(manager, name) {
+        const trimmed = String(name ?? '').trim();
+        if (!trimmed)
+            throw new Error('Database name is required.');
+        return manager.create(trimmed);
+    }
+    static setDatabaseMode(manager, id, readonly, invalidate) {
+        if (!manager.has(id))
+            throw new Error(`Database "${id}" does not exist.`);
+        manager.setReadonly(id, readonly);
+        if (invalidate)
+            invalidate(id);
+    }
+    static removeDatabase(manager, id, invalidate) {
+        if (!manager.has(id))
+            throw new Error(`Database "${id}" does not exist.`);
+        if (invalidate)
+            invalidate(id);
+        manager.remove(id);
+    }
+}
+exports.DatabasesService = DatabasesService;

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

@@ -0,0 +1 @@
+export * from './databases.service';export * from './databases.routes';

package/dist/{routes → modules/databases}/index.js

@@ -14,6 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./pages"), exports);
-__exportStar(require("./databases"), exports);
-__exportStar(require("./api/index"), exports);
+__exportStar(require("./databases.service"), exports);
+__exportStar(require("./databases.routes"), exports);

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

@@ -0,0 +1 @@
+import type {Router} from 'express';import{type RouteContext} from '../../core/router';export declare function registerErdRoutes(router:Router,ctx:RouteContext):void;

package/dist/modules/erd/erd.routes.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerErdRoutes = registerErdRoutes;
+const router_1 = require("../../core/router");
+const tables_service_1 = require("../tables/tables.service");
+const erd_service_1 = require("./erd.service");
+function registerErdRoutes(router, ctx) {
+    router.get('/erd/:db', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            res.locals.dbId = dbId;
+            const tablesList = await tables_service_1.TableService.listTables(db);
+            const allNames = tablesList.map((t) => t.name);
+            (0, router_1.initPageLocals)(res, db, dbId, allNames);
+            res.render('pages/erd', { title: 'ER Diagram', dbId });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/api/erd/:db', async (req, res) => {
+        try {
+            const db = ctx.getContext(req);
+            const graph = await erd_service_1.ErdService.getErdGraph(db);
+            (0, router_1.ok)(res, graph);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Unknown error.', 500);
+        }
+    });
+}

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

@@ -0,0 +1 @@
+import type {DatabaseContext} from '../../core/context';export interface ErdColumn{name:string;type:string;pk:number|boolean;notnull:number|boolean;dflt_value:unknown;}export interface ErdForeignKey{ from :string;table:string;to:string;on_delete:string;on_update:string;}export interface ErdTable{name:string;columns:ErdColumn[];foreignKeys:ErdForeignKey[];primaryKey:string[];}export interface ErdGraph{tables:ErdTable[];}export declare class ErdService{static getErdGraph(ctx:DatabaseContext):Promise<ErdGraph>;}

package/dist/modules/erd/erd.service.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErdService = void 0;
+class ErdService {
+    static async getErdGraph(ctx) {
+        const tablesResult = await ctx.db.listTables();
+        if (!tablesResult.success || !tablesResult.data) {
+            throw new Error(tablesResult.error ?? 'Failed to list tables.');
+        }
+        const tableNames = tablesResult.data.map((t) => t.name);
+        const tables = await Promise.all(tableNames.map(async (name) => {
+            const infoResult = await ctx.db.getTableInfo(name);
+            if (!infoResult.success || !infoResult.data) {
+                return { name, columns: [], foreignKeys: [], primaryKey: [] };
+            }
+            const { columns, foreignKeys, primaryKey } = infoResult.data;
+            return {
+                name,
+                columns: columns.map((c) => ({
+                    name: c.name,
+                    type: c.type,
+                    pk: c.pk,
+                    notnull: c.notnull,
+                    dflt_value: c.dflt_value,
+                })),
+                foreignKeys: foreignKeys.map((fk) => ({
+                    from: fk.from,
+                    table: fk.table,
+                    to: fk.to ?? '',
+                    on_delete: fk.on_delete,
+                    on_update: fk.on_update,
+                })),
+                primaryKey,
+            };
+        }));
+        return { tables };
+    }
+}
+exports.ErdService = ErdService;

package/dist/modules/erd/index.d.ts

@@ -0,0 +1 @@
+export * from './erd.service';export * from './erd.routes';

package/dist/modules/erd/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./erd.service"), exports);
+__exportStar(require("./erd.routes"), exports);

package/dist/modules/index.d.ts

@@ -0,0 +1 @@
+import type {Router} from 'express';import type {RouteContext} from '../core/router';export * from './databases/index';export * from './tables/index';export * from './rows/index';export * from './query/index';export * from './schema/index';export * from './seed/index';export * from './erd/index';export declare function registerModules(router:Router,ctx:RouteContext):void;

package/dist/modules/index.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModules = registerModules;
+const tables_routes_1 = require("./tables/tables.routes");
+const rows_routes_1 = require("./rows/rows.routes");
+const schema_routes_1 = require("./schema/schema.routes");
+const query_routes_1 = require("./query/query.routes");
+const seed_routes_1 = require("./seed/seed.routes");
+const erd_routes_1 = require("./erd/erd.routes");
+__exportStar(require("./databases/index"), exports);
+__exportStar(require("./tables/index"), exports);
+__exportStar(require("./rows/index"), exports);
+__exportStar(require("./query/index"), exports);
+__exportStar(require("./schema/index"), exports);
+__exportStar(require("./seed/index"), exports);
+__exportStar(require("./erd/index"), exports);
+function registerModules(router, ctx) {
+    router.use((req, res, next) => {
+        if (req.method === 'GET')
+            return next();
+        const p = req.path;
+        if (p.endsWith('/generate') ||
+            p.endsWith('/preview') ||
+            p.includes('/api/query/') ||
+            p.endsWith('/rows/bulk-impact') ||
+            p.endsWith('/rows/bulk-export')) {
+            return next();
+        }
+        try {
+            const dbCtx = ctx.getContext(req);
+            if (dbCtx && (dbCtx.isReadOnly || dbCtx.db.isReadOnly)) {
+                return res.status(403).json({
+                    success: false,
+                    error: 'Database is open in read-only mode — write operations are disabled.',
+                });
+            }
+        }
+        catch {
+        }
+        return next();
+    });
+    (0, tables_routes_1.registerTableRoutes)(router, ctx);
+    (0, rows_routes_1.registerRowRoutes)(router, ctx);
+    (0, schema_routes_1.registerSchemaRoutes)(router, ctx);
+    (0, query_routes_1.registerQueryRoutes)(router, ctx);
+    (0, seed_routes_1.registerSeedRoutes)(router, ctx);
+    (0, erd_routes_1.registerErdRoutes)(router, ctx);
+}

package/dist/modules/query/index.d.ts

@@ -0,0 +1 @@
+export * from './query.service';export * from './query.routes';

package/dist/modules/query/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./query.service"), exports);
+__exportStar(require("./query.routes"), exports);

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

@@ -0,0 +1 @@
+import type {Router} from 'express';import{type RouteContext} from '../../core/router';export declare function registerQueryRoutes(router:Router,ctx:RouteContext):void;

package/dist/modules/query/query.routes.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerQueryRoutes = registerQueryRoutes;
+const router_1 = require("../../core/router");
+const tables_service_1 = require("../tables/tables.service");
+const query_service_1 = require("./query.service");
+function registerQueryRoutes(router, ctx) {
+    router.get('/query/:db', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            res.locals.dbId = dbId;
+            const tablesList = await tables_service_1.TableService.listTables(db);
+            const allNames = tablesList.map((t) => t.name);
+            (0, router_1.initPageLocals)(res, db, dbId, allNames);
+            res.render('pages/query', { title: 'Query editor', dbId });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.post('/api/query/:db', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const rawSql = String(req.body?.sql ?? '').trim();
+        if (!rawSql)
+            return (0, router_1.fail)(res, 'SQL query is required.');
+        try {
+            const result = await query_service_1.QueryService.execute(db, rawSql);
+            (0, router_1.ok)(res, result);
+        }
+        catch (err) {
+            if (err instanceof query_service_1.QueryExecutionError) {
+                return (0, router_1.fail)(res, err.message, err.statusCode, err.details);
+            }
+            (0, router_1.fail)(res, err.message ?? 'Query failed.', 500);
+        }
+    }));
+    router.post('/api/query/:db/export', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const sql = String(req.body?.sql ?? '').trim();
+        const format = String(req.body?.format ?? 'csv').toLowerCase() === 'json' ? 'json' : 'csv';
+        if (!sql)
+            return (0, router_1.fail)(res, 'SQL query is required.');
+        try {
+            const exp = await query_service_1.QueryService.streamExportQuery(db, sql, format);
+            res.setHeader('Content-Type', exp.contentType);
+            res.setHeader('Content-Disposition', `attachment; filename="${exp.filename}"`);
+            exp.stream.pipe(res);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Query failed.', 400);
+        }
+    }));
+}

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

@@ -0,0 +1 @@
+import type {DatabaseContext} from '../../core/context';import{type SqlErrorDetails} from '../../sql/error-analyzer';export type QueryExecutionResult={kind:'script';message:string;}|{kind:'select';columns:string[];rows:Record<string,unknown>[];}|{kind:'write';changes:number|null;message:string;};export declare class QueryExecutionError extends Error{readonly statusCode:number;readonly details?:(SqlErrorDetails|Record<string,unknown>|null)|undefined;constructor(message:string,statusCode?:number,details?:(SqlErrorDetails|Record<string,unknown>|null)|undefined);}export declare class QueryService{static execute(ctx:DatabaseContext,rawSql:string):Promise<QueryExecutionResult>;static exportQuery(ctx:DatabaseContext,sql:string,format:'csv'|'json'):Promise<{data:string;contentType:string;filename:string;}>;static streamExportQuery(ctx:DatabaseContext,sql:string,format:'csv'|'json'):Promise<{stream:NodeJS.ReadableStream;contentType:string;filename:string;}>;}

package/dist/modules/query/query.service.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryService = exports.QueryExecutionError = void 0;
+const classifier_1 = require("../../sql/classifier");
+const error_analyzer_1 = require("../../sql/error-analyzer");
+const common_1 = require("../../utils/common");
+const csv_1 = require("../../utils/csv");
+const stream_1 = require("../../utils/stream");
+class QueryExecutionError extends Error {
+    statusCode;
+    details;
+    constructor(message, statusCode = 400, details) {
+        super(message);
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = 'QueryExecutionError';
+    }
+}
+exports.QueryExecutionError = QueryExecutionError;
+class QueryService {
+    static async execute(ctx, rawSql) {
+        const { db } = ctx;
+        const trimmed = String(rawSql ?? '').trim();
+        if (!trimmed) {
+            throw new QueryExecutionError('SQL query is required.', 400);
+        }
+        const { kind } = (0, classifier_1.classifySql)(trimmed);
+        if (db.hasMultipleStatements(trimmed)) {
+            if (db.isReadOnly) {
+                throw new QueryExecutionError('Database is open in read-only mode — write statements are disabled.', 403);
+            }
+            const r = await db.execResult(trimmed);
+            if (!r.success) {
+                const details = await (0, error_analyzer_1.analyzeSqlError)(trimmed, r.error ?? 'Script execution failed.', db);
+                throw new QueryExecutionError(r.error ?? 'Query failed.', 400, details);
+            }
+            return { kind: 'script', message: 'Script executed successfully.' };
+        }
+        if (kind === 'select' || kind === 'read' || kind === 'count') {
+            const r = await db.all(trimmed);
+            if (!r.success) {
+                const details = await (0, error_analyzer_1.analyzeSqlError)(trimmed, r.error ?? 'Query execution failed.', db);
+                throw new QueryExecutionError(r.error ?? 'Query failed.', 400, details);
+            }
+            const rows = (r.data ?? []).map(common_1.normalizeRow);
+            return { kind: 'select', columns: rows.length ? Object.keys(rows[0]) : [], rows };
+        }
+        if (db.isReadOnly) {
+            throw new QueryExecutionError('Database is open in read-only mode — write statements are disabled.', 403);
+        }
+        const r = await db.runWrite(trimmed);
+        if (!r.success) {
+            const details = await (0, error_analyzer_1.analyzeSqlError)(trimmed, r.error ?? 'Statement execution failed.', db);
+            throw new QueryExecutionError(r.error ?? 'Query failed.', 400, details);
+        }
+        const changes = r.data?.changes;
+        return {
+            kind: 'write',
+            changes: changes ?? null,
+            message: changes != null ? `${changes} row(s) affected.` : 'Statement executed successfully.',
+        };
+    }
+    static async exportQuery(ctx, sql, format) {
+        const trimmed = String(sql ?? '').trim();
+        if (!trimmed)
+            throw new QueryExecutionError('SQL query is required.', 400);
+        const r = await ctx.db.all(trimmed);
+        if (!r.success)
+            throw new QueryExecutionError(r.error ?? 'Query failed.', 400);
+        const rows = (r.data ?? []).map(common_1.normalizeRow);
+        const columns = rows.length ? Object.keys(rows[0]) : [];
+        if (format === 'json') {
+            return { data: (0, csv_1.toJson)(rows), contentType: 'application/json; charset=utf-8', filename: 'query_results.json' };
+        }
+        return { data: (0, csv_1.toCsv)(rows, columns), contentType: 'text/csv; charset=utf-8', filename: 'query_results.csv' };
+    }
+    static async streamExportQuery(ctx, sql, format) {
+        const result = await QueryService.execute(ctx, sql);
+        if (result.kind !== 'select') {
+            throw new QueryExecutionError('Query must be a SELECT statement to export.', 400);
+        }
+        const columns = result.columns;
+        const transform = format === 'json' ? (0, stream_1.createJsonStream)() : (0, stream_1.createCsvStream)(columns);
+        process.nextTick(() => {
+            for (const row of result.rows) {
+                transform.write(row);
+            }
+            transform.end();
+        });
+        const contentType = format === 'json' ? 'application/json; charset=utf-8' : 'text/csv; charset=utf-8';
+        const filename = `query_results.${format}`;
+        return { stream: transform, contentType, filename };
+    }
+}
+exports.QueryService = QueryService;

package/dist/modules/rows/blob.helper.d.ts

@@ -0,0 +1 @@
+import{type MimeAnalysis,type BlobMetadata} from '../../utils/datatype';export declare function resolveBlobBuffer(rawVal:unknown):Buffer;export declare function parseBlobPayload(data:unknown,format?:string):Buffer;export declare function getBlobMetadata(rawVal:unknown):{isNull:boolean;}&(Partial<BlobMetadata>);export declare function sniffBlobMime(buf:Buffer):MimeAnalysis;

package/dist/modules/rows/blob.helper.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBlobBuffer = resolveBlobBuffer;
+exports.parseBlobPayload = parseBlobPayload;
+exports.getBlobMetadata = getBlobMetadata;
+exports.sniffBlobMime = sniffBlobMime;
+const datatype_1 = require("../../utils/datatype");
+function resolveBlobBuffer(rawVal) {
+    if (Buffer.isBuffer(rawVal) || rawVal instanceof Uint8Array) {
+        return Buffer.isBuffer(rawVal) ? rawVal : Buffer.from(rawVal);
+    }
+    if (typeof rawVal === 'string' && /^0x[0-9a-f]*$/i.test(rawVal)) {
+        return Buffer.from(rawVal.slice(2), 'hex');
+    }
+    return Buffer.from(String(rawVal ?? ''), 'utf8');
+}
+function parseBlobPayload(data, format = 'base64') {
+    if (data === undefined || data === null) {
+        throw new Error('Payload data is required.');
+    }
+    if (format === 'base64') {
+        const base64Str = String(data).replace(/^data:[^;]+;base64,/, '');
+        return Buffer.from(base64Str, 'base64');
+    }
+    if (format === 'hex') {
+        const hexStr = String(data).replace(/^0x/i, '');
+        return Buffer.from(hexStr, 'hex');
+    }
+    return Buffer.from(String(data), 'utf8');
+}
+function getBlobMetadata(rawVal) {
+    if (rawVal === null || rawVal === undefined) {
+        return { isNull: true, size: 0, sizeFormatted: '0 B' };
+    }
+    const meta = (0, datatype_1.analyzeBlob)(rawVal);
+    return { isNull: false, ...meta };
+}
+function sniffBlobMime(buf) {
+    return (0, datatype_1.sniffMimeType)(buf);
+}

package/dist/modules/rows/display.helper.d.ts

@@ -0,0 +1 @@
+import type {TableInfoData} from '../../db/index';export interface DisplayCell{name:string;value:unknown;isNull:boolean;display:string;type?:string;isBlob?:boolean;isJson?:boolean;isImage?:boolean;isUrl?:boolean;isColor?:boolean;blobSize?:string;blobMime?:string;blobExt?:string;blobUrl?:string;}export interface DisplayRow{cells:DisplayCell[];pkEncoded:string|null;refs?:{table:string; from :string;to:string;value:string;count:number;}[];}export declare function buildDisplayRows(rawRows:Record<string,unknown>[],info:TableInfoData,dbId?:string,table?:string,basePath?:string):DisplayRow[];

package/dist/modules/rows/display.helper.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDisplayRows = buildDisplayRows;
+const common_1 = require("../../utils/common");
+const datatype_1 = require("../../utils/datatype");
+const blob_helper_1 = require("./blob.helper");
+function buildDisplayRows(rawRows, info, dbId, table, basePath = '') {
+    const pkCols = info.primaryKey.length ? info.primaryKey : ['_rowid_'];
+    return rawRows.map((row) => {
+        const pkEncoded = (0, common_1.encodePk)(pkCols.map((c) => row[c]));
+        return {
+            cells: info.columns.map((c) => {
+                const raw = row[c.name];
+                const v = (0, common_1.normalizeCell)(raw);
+                const isNull = v == null;
+                const typeUpper = (c.type || '').toUpperCase();
+                const isBlob = typeUpper.includes('BLOB') ||
+                    typeUpper.includes('BYTEA') ||
+                    Buffer.isBuffer(raw) ||
+                    raw instanceof Uint8Array ||
+                    (typeof v === 'string' && (/^0x[0-9a-f]{8,}$/i.test(v) || /^\\x[0-9a-f]{8,}$/i.test(v)));
+                let isJson = false;
+                let isImage = false;
+                let isUrl = false;
+                let isColor = false;
+                let blobSize = '';
+                let blobMime = '';
+                let blobExt = '';
+                let blobUrl = '';
+                if (!isNull) {
+                    const str = String(v);
+                    if (isBlob) {
+                        const buf = (0, blob_helper_1.resolveBlobBuffer)(raw ?? v);
+                        const mimeInfo = (0, blob_helper_1.sniffBlobMime)(buf);
+                        blobSize = (0, common_1.formatBytes)(buf.length);
+                        blobMime = mimeInfo.mime;
+                        blobExt = mimeInfo.ext;
+                        isImage = mimeInfo.isImage;
+                        if (table && pkEncoded && dbId) {
+                            blobUrl = `${basePath}/api/tables/${encodeURIComponent(dbId)}/${encodeURIComponent(table)}/row/${encodeURIComponent(pkEncoded)}/blob/${encodeURIComponent(c.name)}`;
+                        }
+                    }
+                    else if ((0, datatype_1.isJsonString)(v) || typeUpper.includes('JSON')) {
+                        isJson = (0, datatype_1.isJsonString)(v);
+                    }
+                    else {
+                        if (/^https?:\/\/[^\s$.?#].[^\s]*$/i.test(str))
+                            isUrl = true;
+                        else if (/^#(?:[0-9a-fA-F]{3}){1,2}$|^rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+/i.test(str))
+                            isColor = true;
+                    }
+                }
+                return {
+                    name: c.name,
+                    value: v,
+                    isNull,
+                    display: isNull ? '' : String(v),
+                    type: c.type,
+                    isBlob,
+                    isJson,
+                    isImage,
+                    isUrl,
+                    isColor,
+                    blobSize,
+                    blobMime,
+                    blobExt,
+                    blobUrl,
+                };
+            }),
+            pkEncoded,
+        };
+    });
+}

package/dist/modules/rows/index.d.ts

@@ -0,0 +1 @@
+export * from './blob.helper';export * from './display.helper';export * from './rows.service';export * from './rows.routes';

package/dist/modules/rows/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./blob.helper"), exports);
+__exportStar(require("./display.helper"), exports);
+__exportStar(require("./rows.service"), exports);
+__exportStar(require("./rows.routes"), exports);

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

@@ -0,0 +1 @@
+import type {Router} from 'express';import{type RouteContext} from '../../core/router';export declare function registerRowRoutes(router:Router,ctx:RouteContext):void;