admindb 2.4.0 → 2.5.0

package/dist/modules/tables/tables.routes.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTableRoutes = registerTableRoutes;
+const router_1 = require("../../core/router");
+const tables_service_1 = require("./tables.service");
+function registerTableRoutes(router, ctx) {
+    router.get('/home/:db', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            const tablesList = await tables_service_1.TableService.listTables(db);
+            const allNames = tablesList.map((t) => t.name);
+            const { tables: names } = (0, router_1.initPageLocals)(res, db, dbId, allNames);
+            const homeData = await tables_service_1.TableService.getHomeStats(db, names);
+            res.render('pages/home', {
+                title: 'Home',
+                dbId,
+                tables: names,
+                counts: homeData.counts,
+                cols: homeData.cols,
+                totalRows: homeData.totalRows,
+                dbPath: db.path,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/info/:db', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            res.locals.dbId = dbId;
+            const dbInfo = await tables_service_1.TableService.getDatabaseInfo(db);
+            (0, router_1.initPageLocals)(res, db, dbId, dbInfo.tables);
+            res.render('pages/info', {
+                title: 'Database Info',
+                dbId,
+                settings: dbInfo.settings,
+                dialect: dbInfo.dialect,
+                dbPath: dbInfo.dbPath,
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/export/:db', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            const data = await tables_service_1.TableService.getSqlDump(db);
+            const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+            res.setHeader('Content-Type', 'application/sql; charset=utf-8');
+            res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(dbId)}-${stamp}.sql"`);
+            res.send(data);
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/api/tables/:db', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        try {
+            const tables = await tables_service_1.TableService.listTables(db);
+            (0, router_1.ok)(res, tables);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to list tables.', 500);
+        }
+    }));
+    router.get('/api/tables/:db/:table/info', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        (0, router_1.ok)(res, info);
+    }));
+    router.get('/api/tables/:db/:table/fk-options', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const info = await tables_service_1.TableService.getTableInfo(db, req.params.table);
+        if (!info)
+            return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+        const options = await tables_service_1.TableService.getFkOptions(db, req.params.table, info);
+        (0, router_1.ok)(res, options);
+    }));
+    router.get('/api/tables/:db/:table/ddl', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        try {
+            const ddl = await tables_service_1.TableService.getTableDdl(db, req.params.table);
+            if (!ddl)
+                return (0, router_1.fail)(res, `Table "${req.params.table}" does not exist.`, 404);
+            (0, router_1.ok)(res, { sql: ddl });
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to fetch DDL.', 500);
+        }
+    }));
+    router.get('/api/info/:db/ddl', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        try {
+            const dump = await tables_service_1.TableService.getSchemaDump(db);
+            (0, router_1.ok)(res, dump);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to export schema DDL.', 500);
+        }
+    }));
+    router.post('/api/tables/:db/:table/rename', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const newName = String(req.body?.name ?? '').trim();
+        if (!newName)
+            return (0, router_1.fail)(res, 'New table name is required.');
+        try {
+            await tables_service_1.TableService.renameTable(db, req.params.table, newName);
+            (0, router_1.ok)(res, { message: `Table renamed to "${newName}".`, name: newName });
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to rename table.');
+        }
+    }));
+    router.delete('/api/tables/:db/:table', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        try {
+            await tables_service_1.TableService.dropTable(db, req.params.table);
+            (0, router_1.ok)(res, { message: `Table "${req.params.table}" dropped.` });
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to drop table.');
+        }
+    }));
+    router.post('/api/tables/:db/bulk-drop', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const tables = Array.isArray(req.body?.tables)
+            ? req.body.tables.filter((t) => typeof t === 'string' && t.trim().length > 0)
+            : [];
+        const force = Boolean(req.body?.force);
+        if (tables.length === 0)
+            return (0, router_1.fail)(res, 'No tables specified.');
+        const { dropped, failed } = await tables_service_1.TableService.bulkDropTables(db, tables, force);
+        (0, router_1.ok)(res, {
+            dropped,
+            failed,
+            message: `Dropped ${dropped.length} table(s)${failed.length ? `, ${failed.length} failed` : ''}.`,
+        });
+    }));
+    router.post('/api/tables/:db/bulk-truncate', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const tables = Array.isArray(req.body?.tables)
+            ? req.body.tables.filter((t) => typeof t === 'string' && t.trim().length > 0)
+            : [];
+        const force = Boolean(req.body?.force);
+        if (tables.length === 0)
+            return (0, router_1.fail)(res, 'No tables specified.');
+        const { cleared, failed } = await tables_service_1.TableService.bulkTruncateTables(db, tables, force);
+        (0, router_1.ok)(res, {
+            cleared,
+            failed,
+            message: `Cleared ${cleared.length} table(s)${failed.length ? `, ${failed.length} failed` : ''}.`,
+        });
+    }));
+    router.post('/api/tables/:db/generate', (0, router_1.wrap)(async (req, res) => {
+        const name = String(req.body?.name ?? '').trim();
+        const columns = (req.body?.columns ?? []);
+        if (!name)
+            return (0, router_1.fail)(res, 'Table name is required.');
+        if (!Array.isArray(columns) || columns.length === 0)
+            return (0, router_1.fail)(res, 'At least one column is required.');
+        try {
+            (0, router_1.ok)(res, { sql: tables_service_1.TableService.generateCreateTableSql(name, columns) });
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message);
+        }
+    }));
+    const createTableHandler = (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const name = String(req.body?.name ?? '').trim();
+        const columns = (req.body?.columns ?? []);
+        if (!name)
+            return (0, router_1.fail)(res, 'Table name is required.');
+        if (!Array.isArray(columns) || columns.length === 0)
+            return (0, router_1.fail)(res, 'At least one column is required.');
+        try {
+            await tables_service_1.TableService.createTable(db, name, columns);
+            (0, router_1.ok)(res, { message: `Table "${name}" created.`, name }, 201);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to create table.');
+        }
+    });
+    router.post('/api/tables/:db', createTableHandler);
+    router.post('/api/tables/:db/create', createTableHandler);
+}

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

@@ -0,0 +1 @@
+import type {TableInfoData} from '../../db/index';import type {DatabaseContext} from '../../core/context';import{type ColumnDef} from '../../sql/generator';export interface FkOption{value:unknown;label:string;}export interface BulkOperationResult{succeeded:string[];failed:{table:string;error:string;}[];message:string;}export interface TableHomeStat{name:string;count:number;cols:number;}export interface HomeSummaryData{stats:TableHomeStat[];counts:Record<string,number>;cols:Record<string,number>;totalRows:number;savedQueriesCount:number;}export interface DatabaseInfoResult{settings:Record<string,unknown>;tables:string[];dialect:string;dbPath:string;}export declare class TableService{static listTables(ctx:DatabaseContext):Promise<import("../../db/types").TableListItem[]>;static getTableInfo(ctx:DatabaseContext,table:string):Promise<TableInfoData|null>;static requireTable(ctx:DatabaseContext,table:string):Promise<TableInfoData>;static getFkOptions(ctx:DatabaseContext,table:string,info?:TableInfoData):Promise<Record<string,FkOption[]>>;static getTableDdl(ctx:DatabaseContext,table:string):Promise<string|null>;static renameTable(ctx:DatabaseContext,table:string,newName:string):Promise<void>;static dropTable(ctx:DatabaseContext,table:string):Promise<void>;static bulkDropTables(ctx:DatabaseContext,tables:string[],force?:boolean):Promise<{dropped:string[];failed:{table:string;error:string;}[];}>;static bulkTruncateTables(ctx:DatabaseContext,tables:string[],force?:boolean):Promise<{cleared:string[];failed:{table:string;error:string;}[];}>;static getIncomingForeignKeyCounts(ctx:DatabaseContext,rawRows:Record<string,unknown>[],refColumns:{table:string; from :string;to:string;}[]):Promise<Map<string,Map<string,number>>>;static getDatabaseInfo(ctx:DatabaseContext):Promise<DatabaseInfoResult>;static getSchemaDump(ctx:DatabaseContext):Promise<string>;static getSqlDump(ctx:DatabaseContext):Promise<string>;static getHomeStats(ctx:DatabaseContext,tableNames:string[]):Promise<HomeSummaryData>;static generateCreateTableSql(name:string,columns:ColumnDef[]):string;static createTable(ctx:DatabaseContext,name:string,columns:ColumnDef[]):Promise<void>;}

package/dist/modules/tables/tables.service.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableService = void 0;
+const generator_1 = require("../../sql/generator");
+const export_1 = require("../../db/export");
+class TableService {
+    static async listTables(ctx) {
+        const r = await ctx.db.listTables();
+        if (!r.success) {
+            throw new Error(r.error ?? 'Failed to list tables.');
+        }
+        return r.data ?? [];
+    }
+    static async getTableInfo(ctx, table) {
+        const info = await ctx.db.getTableInfo(table);
+        if (!info.success || !info.data?.columns?.length) {
+            return null;
+        }
+        return info.data;
+    }
+    static async requireTable(ctx, table) {
+        const info = await TableService.getTableInfo(ctx, table);
+        if (!info) {
+            throw new Error(`Table "${table}" does not exist.`);
+        }
+        return info;
+    }
+    static async getFkOptions(ctx, table, info) {
+        const tableInfo = info ?? (await TableService.requireTable(ctx, table));
+        const options = {};
+        for (const fk of tableInfo.foreignKeys) {
+            try {
+                const refInfo = await TableService.getTableInfo(ctx, fk.table);
+                if (!refInfo)
+                    continue;
+                const refCol = fk.to || refInfo.primaryKey[0] || refInfo.columns[0]?.name;
+                const pk = refInfo.primaryKey[0] ?? refInfo.columns[0]?.name;
+                const labelCol = refInfo.columns.find((c) => /name|title|label|username|email/i.test(c.name))?.name ?? pk;
+                const rows = await ctx.db.getRows(fk.table, { limit: 100, orderBy: labelCol });
+                if (rows.success && rows.data) {
+                    options[fk.from] = rows.data.map((r) => ({
+                        value: r[refCol],
+                        label: r[labelCol] != null ? `${r[labelCol]} (${r[refCol]})` : String(r[refCol]),
+                    }));
+                }
+            }
+            catch {
+            }
+        }
+        return options;
+    }
+    static async getTableDdl(ctx, table) {
+        const r = await ctx.db.getCreateStatement(table);
+        if (!r.success) {
+            throw new Error(r.error ?? 'Failed to fetch DDL.');
+        }
+        return r.data ?? null;
+    }
+    static async renameTable(ctx, table, newName) {
+        const trimmed = String(newName ?? '').trim();
+        if (!trimmed)
+            throw new Error('New table name is required.');
+        const r = await ctx.db.renameTable(table, trimmed);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to rename table.');
+    }
+    static async dropTable(ctx, table) {
+        const r = await ctx.db.dropTable(table);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to drop table.');
+    }
+    static async bulkDropTables(ctx, tables, force = false) {
+        if (tables.length === 0)
+            throw new Error('No tables specified.');
+        const dropped = [];
+        const failed = [];
+        const { db, dialect } = ctx;
+        if (force && dialect.ddl.setForeignKeys) {
+            await db.run(dialect.ddl.setForeignKeys(false));
+        }
+        for (const table of tables) {
+            try {
+                const dropSql = dialect.ddl.dropTable(table, { cascade: force, ifExists: force });
+                const r = await db.run(dropSql);
+                if (!r.success)
+                    throw new Error(r.error ?? 'Failed to drop table.');
+                dropped.push(table);
+            }
+            catch (err) {
+                failed.push({ table, error: err.message });
+            }
+        }
+        if (force && dialect.ddl.setForeignKeys) {
+            await db.run(dialect.ddl.setForeignKeys(true));
+        }
+        return { dropped, failed };
+    }
+    static async bulkTruncateTables(ctx, tables, force = false) {
+        if (tables.length === 0)
+            throw new Error('No tables specified.');
+        const cleared = [];
+        const failed = [];
+        const { db, dialect } = ctx;
+        if (force && dialect.ddl.setForeignKeys) {
+            await db.run(dialect.ddl.setForeignKeys(false));
+        }
+        for (const table of tables) {
+            try {
+                const truncateSql = dialect.ddl.truncateTable(table, { cascade: force, restartIdentity: force });
+                const r = await db.run(truncateSql);
+                if (!r.success)
+                    throw new Error(r.error ?? 'Failed to clear table.');
+                cleared.push(table);
+            }
+            catch (err) {
+                failed.push({ table, error: err.message });
+            }
+        }
+        if (force && dialect.ddl.setForeignKeys) {
+            await db.run(dialect.ddl.setForeignKeys(true));
+        }
+        return { cleared, failed };
+    }
+    static async getIncomingForeignKeyCounts(ctx, rawRows, refColumns) {
+        const { db } = ctx;
+        const countEntries = await Promise.all(refColumns.map(async (col) => {
+            const values = rawRows
+                .map((r) => r[col.to])
+                .filter((v) => v !== null && v !== undefined);
+            if (!values.length)
+                return [col.table, new Map()];
+            const placeholders = values.map(() => '?').join(', ');
+            const cR = await db.all(`SELECT ${(0, generator_1.quoteIdentifier)(col.from)} AS fk, COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(col.table)} WHERE ${(0, generator_1.quoteIdentifier)(col.from)} IN (${placeholders}) GROUP BY ${(0, generator_1.quoteIdentifier)(col.from)}`, values);
+            const map = new Map();
+            for (const row of (cR.data ?? [])) {
+                map.set(String(row.fk), Number(row.c));
+            }
+            return [col.table, map];
+        }));
+        return new Map(countEntries);
+    }
+    static async getDatabaseInfo(ctx) {
+        const all = await ctx.db.listTables();
+        const tables = (all.data ?? []).map((t) => t.name);
+        const settingsRes = await ctx.db.getSettings();
+        return {
+            settings: settingsRes.success && settingsRes.data ? settingsRes.data : {},
+            tables,
+            dialect: ctx.dialect.name,
+            dbPath: ctx.path,
+        };
+    }
+    static async getSchemaDump(ctx) {
+        const dump = await (0, export_1.generateSchemaDump)(ctx.db);
+        if (!dump.success || !dump.data) {
+            throw new Error(dump.error ?? 'Failed to generate schema dump.');
+        }
+        return dump.data;
+    }
+    static async getSqlDump(ctx) {
+        const dump = await (0, export_1.generateSqlDump)(ctx.db);
+        if (!dump.success || !dump.data) {
+            throw new Error(dump.error ?? 'Failed to generate SQL dump.');
+        }
+        return dump.data;
+    }
+    static async getHomeStats(ctx, tableNames) {
+        const { db, dialect } = ctx;
+        let colCountsMap = {};
+        if (dialect.introspector.getColumnCountMap) {
+            const colCountRes = await dialect.introspector.getColumnCountMap(db);
+            if (colCountRes.success && colCountRes.data) {
+                colCountsMap = colCountRes.data;
+            }
+        }
+        const stats = await Promise.all(tableNames.map(async (name) => {
+            const countR = await db.getRowCount(name);
+            const cols = colCountsMap[name] !== undefined
+                ? colCountsMap[name]
+                : (await db.getTableInfo(name)).data?.columns.length ?? 0;
+            return {
+                name,
+                count: countR.success ? countR.data : 0,
+                cols,
+            };
+        }));
+        const counts = {};
+        const cols = {};
+        let totalRows = 0;
+        for (const s of stats) {
+            counts[s.name] = s.count;
+            cols[s.name] = s.cols;
+            totalRows += s.count;
+        }
+        return {
+            stats,
+            counts,
+            cols,
+            totalRows,
+            savedQueriesCount: 0,
+        };
+    }
+    static generateCreateTableSql(name, columns) {
+        const trimmed = String(name ?? '').trim();
+        if (!trimmed)
+            throw new Error('Table name is required.');
+        if (!Array.isArray(columns) || columns.length === 0)
+            throw new Error('At least one column is required.');
+        return (0, generator_1.generateCreateTable)(trimmed, columns);
+    }
+    static async createTable(ctx, name, columns) {
+        const sql = TableService.generateCreateTableSql(name, columns);
+        const r = await ctx.db.execResult(sql);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to create table.');
+    }
+}
+exports.TableService = TableService;