admindb 2.4.0 → 2.5.0

package/dist/modules/rows/rows.service.js

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowsService = exports.MAX_BULK_ROWS = void 0;
+exports.buildFields = buildFields;
+exports.buildUpdateFields = buildUpdateFields;
+exports.pkWhere = pkWhere;
+exports.resolvePkRows = resolvePkRows;
+exports.computeBulkImpact = computeBulkImpact;
+exports.encodeCursor = encodeCursor;
+exports.decodeCursor = decodeCursor;
+const common_1 = require("../../utils/common");
+const csv_1 = require("../../utils/csv");
+const stream_1 = require("../../utils/stream");
+const generator_1 = require("../../sql/generator");
+const blob_helper_1 = require("./blob.helper");
+exports.MAX_BULK_ROWS = 1000;
+function buildFields(info, values, opts = {}) {
+    const typeMap = new Map(info.columns.map((c) => [c.name, c.type]));
+    const pkSet = new Set(info.primaryKey);
+    const fields = [];
+    for (const [col, raw] of Object.entries(values ?? {})) {
+        if (!typeMap.has(col) || (opts.excludePk && pkSet.has(col)))
+            continue;
+        const val = (0, common_1.coerceFormValue)(raw, typeMap.get(col));
+        if (val !== null)
+            fields.push({ column: col, value: val });
+    }
+    return fields;
+}
+function buildUpdateFields(info, values, nulls) {
+    const fields = buildFields(info, values, { excludePk: true });
+    const typeMap = new Map(info.columns.map((c) => [c.name, c.type]));
+    const pkSet = new Set(info.primaryKey);
+    for (const col of nulls) {
+        if (!pkSet.has(col) && typeMap.has(col) && !fields.some((f) => f.column === col)) {
+            fields.push({ column: col, value: null });
+        }
+    }
+    return fields;
+}
+function pkWhere(info, encodedId) {
+    const vals = (0, common_1.decodePk)(encodedId);
+    if (!info.primaryKey.length) {
+        if (vals.length === 1 && vals[0] !== '') {
+            const num = Number(vals[0]);
+            return [{ column: '_rowid_', value: Number.isFinite(num) ? num : vals[0] }];
+        }
+        return null;
+    }
+    if (vals.length !== info.primaryKey.length)
+        return null;
+    const typeMap = new Map(info.columns.map((c) => [c.name, c.type]));
+    return info.primaryKey.map((col, i) => ({ column: col, value: (0, common_1.coerceFormValue)(vals[i], typeMap.get(col)) }));
+}
+function resolvePkRows(info, ids) {
+    const list = Array.isArray(ids) ? ids : ids == null ? [] : [ids];
+    const out = [];
+    for (const id of list) {
+        const where = pkWhere(info, String(id));
+        if (where)
+            out.push(where);
+    }
+    return out.length ? out : null;
+}
+async function computeBulkImpact(ctx, info, wheres) {
+    const { db } = ctx;
+    const [rowsR, refInfoR] = await Promise.all([
+        db.getRowsByPks(info.table, wheres),
+        db.getReferencingTables(info.table),
+    ]);
+    const rows = (rowsR.data ?? []);
+    const referencing = refInfoR.data ?? [];
+    if (!rows.length || !referencing.length)
+        return { references: [], total: 0 };
+    const queries = referencing.flatMap((item) => item.refs.map(async (ref) => {
+        const targetCol = ref.to || info.primaryKey[0];
+        if (!targetCol)
+            return null;
+        const values = Array.from(new Set(rows.map((r) => r[targetCol]).filter((v) => v != null)));
+        if (!values.length)
+            return null;
+        try {
+            const placeholders = values.map(() => '?').join(', ');
+            const sql = `SELECT COUNT(*) AS c FROM ${(0, generator_1.quoteIdentifier)(item.table)} WHERE ${(0, generator_1.quoteIdentifier)(ref.from)} IN (${placeholders})`;
+            const countR = await db.all(sql, values);
+            const count = countR.success && countR.data?.[0] ? Number(countR.data[0].c ?? 0) : 0;
+            return count > 0 ? { table: item.table, from: ref.from, to: targetCol, count } : null;
+        }
+        catch {
+            return null;
+        }
+    }));
+    const results = (await Promise.all(queries)).filter((r) => r !== null);
+    const total = results.reduce((acc, r) => acc + r.count, 0);
+    return { references: results, total };
+}
+function encodeCursor(values) {
+    return Buffer.from(JSON.stringify(values)).toString('base64url');
+}
+function decodeCursor(cursor) {
+    try {
+        return JSON.parse(Buffer.from(cursor, 'base64url').toString('utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+class RowsService {
+    static async getPaginatedRows(ctx, table, options = {}) {
+        const { db } = ctx;
+        const page = options.page ?? 1;
+        const limit = options.limit ?? 50;
+        const [rowsR, totalR] = await Promise.all([
+            db.getRows(table, { ...options, page, limit }),
+            db.getRowCount(table, options.filters),
+        ]);
+        if (!rowsR.success) {
+            throw new Error(rowsR.error ?? 'Failed to load rows.');
+        }
+        const rows = (rowsR.data ?? []).map(common_1.normalizeRow);
+        const total = totalR.success && typeof totalR.data === 'number' ? totalR.data : rows.length;
+        return {
+            rows,
+            total,
+            page,
+            limit,
+        };
+    }
+    static async getCursorPaginatedRows(ctx, table, options = {}) {
+        const { db } = ctx;
+        const limit = Math.max(1, Math.min(500, options.limit ?? 50));
+        const orderDir = options.orderDir === 'desc' ? 'desc' : 'asc';
+        const info = await db.getTableInfo(table);
+        const tableInfo = info.data;
+        const pkCol = tableInfo?.primaryKey[0] ?? '_rowid_';
+        const orderBy = options.orderBy ?? pkCol;
+        const filters = { ...(options.filters ?? {}) };
+        const decodedCursor = options.cursor ? decodeCursor(options.cursor) : null;
+        if (decodedCursor && decodedCursor[orderBy] !== undefined) {
+            const cursorVal = decodedCursor[orderBy];
+            const op = orderDir === 'asc' ? 'gt' : 'lt';
+            filters[orderBy] = { op, value: String(cursorVal) };
+        }
+        const rowsR = await db.getRows(table, {
+            filters,
+            orderBy,
+            orderDir,
+            limit: limit + 1,
+        });
+        if (!rowsR.success) {
+            throw new Error(rowsR.error ?? 'Failed to load cursor-paginated rows.');
+        }
+        const rawRows = (rowsR.data ?? []).map(common_1.normalizeRow);
+        const hasMore = rawRows.length > limit;
+        const rows = hasMore ? rawRows.slice(0, limit) : rawRows;
+        let nextCursor = null;
+        let prevCursor = null;
+        if (rows.length > 0) {
+            const firstRow = rows[0];
+            const lastRow = rows[rows.length - 1];
+            if (hasMore) {
+                nextCursor = encodeCursor({ [orderBy]: lastRow[orderBy], [pkCol]: lastRow[pkCol] });
+            }
+            if (options.cursor) {
+                prevCursor = encodeCursor({ [orderBy]: firstRow[orderBy], [pkCol]: firstRow[pkCol] });
+            }
+        }
+        return {
+            rows,
+            nextCursor,
+            prevCursor,
+            hasMore,
+            limit,
+        };
+    }
+    static async getRowCount(ctx, table, filters) {
+        const r = await ctx.db.getRowCount(table, filters);
+        if (!r.success) {
+            throw new Error(r.error ?? 'Failed to count rows.');
+        }
+        return r.data ?? 0;
+    }
+    static async getRow(ctx, table, where) {
+        const r = await ctx.db.getRow(table, where);
+        if (!r.success) {
+            throw new Error(r.error ?? 'Failed to load row.');
+        }
+        return r.data ? (0, common_1.normalizeRow)(r.data) : null;
+    }
+    static async getBlob(ctx, table, where, column) {
+        const r = await ctx.db.getRow(table, where);
+        if (!r.success) {
+            throw new Error(r.error ?? 'Failed to load row.');
+        }
+        if (!r.data)
+            return null;
+        const rawVal = r.data[column];
+        if (rawVal === null || rawVal === undefined)
+            return null;
+        const buf = (0, blob_helper_1.resolveBlobBuffer)(rawVal);
+        const mimeInfo = (0, blob_helper_1.sniffBlobMime)(buf);
+        return { buffer: buf, mimeInfo };
+    }
+    static async getBlobMeta(ctx, table, where, column) {
+        const r = await ctx.db.getRow(table, where);
+        if (!r.success) {
+            throw new Error(r.error ?? 'Failed to load row.');
+        }
+        if (!r.data)
+            return null;
+        const rawVal = r.data[column];
+        return (0, blob_helper_1.getBlobMetadata)(rawVal);
+    }
+    static async updateBlob(ctx, table, where, column, data, format) {
+        const buf = (0, blob_helper_1.parseBlobPayload)(data, format);
+        const updateRes = await ctx.db.updateRow(table, [{ column, value: buf }], where);
+        if (!updateRes.success) {
+            throw new Error(updateRes.error ?? 'Failed to update BLOB.');
+        }
+        return buf.length;
+    }
+    static generateInsertSql(table, fields) {
+        if (!fields.length)
+            throw new Error('No valid column values provided.');
+        return (0, generator_1.generateInsert)(table, fields);
+    }
+    static generateUpdateSql(table, fields, where) {
+        if (!fields.length)
+            throw new Error('No fields to update.');
+        return (0, generator_1.generateUpdate)(table, fields, where);
+    }
+    static async insertRow(ctx, table, fields) {
+        if (!fields.length)
+            throw new Error('No valid column values provided.');
+        const r = await ctx.db.insertRow(table, fields);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to insert row.');
+        return r.data?.lastInsertRowid;
+    }
+    static async insertRows(ctx, table, fieldsList) {
+        if (!fieldsList.length)
+            throw new Error('No rows provided.');
+        const r = await ctx.db.insertRows(table, fieldsList);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to insert rows.');
+        return r.data?.inserted ?? 0;
+    }
+    static async updateRow(ctx, table, fields, where) {
+        if (!fields.length)
+            throw new Error('No fields to update.');
+        const r = await ctx.db.updateRow(table, fields, where);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to update row.');
+    }
+    static async updateRows(ctx, table, rowUpdates) {
+        if (!rowUpdates.length)
+            return 0;
+        const r = await ctx.db.updateRows(table, rowUpdates);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to update rows.');
+        return r.data?.updated ?? 0;
+    }
+    static async deleteRow(ctx, table, where) {
+        const r = await ctx.db.deleteRow(table, where);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to delete row.');
+    }
+    static async deleteRows(ctx, table, wheres) {
+        const r = await ctx.db.deleteRows(table, wheres);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to delete rows.');
+        return r.data?.deleted ?? 0;
+    }
+    static async getRowReferences(ctx, table, info, where) {
+        const { db } = ctx;
+        const rowR = await db.getRow(table, where);
+        if (!rowR.success || !rowR.data) {
+            throw new Error('Row not found.');
+        }
+        const refInfoR = await db.getReferencingTables(table);
+        const referencing = refInfoR.data ?? [];
+        const results = [];
+        for (const item of referencing) {
+            for (const ref of item.refs) {
+                const targetCol = ref.to || info.primaryKey[0];
+                if (!targetCol)
+                    continue;
+                const val = rowR.data[targetCol];
+                if (val == null)
+                    continue;
+                const fkR = await db.getRowsByFk(item.table, ref.from, val);
+                if (fkR.success && fkR.data) {
+                    const rows = fkR.data.rows.map(common_1.normalizeRow);
+                    results.push({
+                        table: item.table,
+                        from: ref.from,
+                        to: targetCol,
+                        value: val,
+                        columns: rows.length > 0 ? Object.keys(rows[0]) : [],
+                        rows,
+                        count: fkR.data.total,
+                        total: fkR.data.total,
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    static async exportTable(ctx, table, info, options) {
+        const r = await ctx.db.getRows(table, { limit: options.limit ?? 1_000_000, filters: options.filters });
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to export table.');
+        const rows = (r.data ?? []).map(common_1.normalizeRow);
+        const columns = info.columns.map((c) => c.name);
+        if (options.format === 'json') {
+            return { data: (0, csv_1.toJson)(rows), contentType: 'application/json; charset=utf-8', filename: `${table}.json` };
+        }
+        return { data: (0, csv_1.toCsv)(rows, columns), contentType: 'text/csv; charset=utf-8', filename: `${table}.csv` };
+    }
+    static async streamExportTable(ctx, table, info, options) {
+        const chunkSize = Math.max(10, options.chunkSize ?? 500);
+        const columns = info.columns.map((c) => c.name);
+        const transform = options.format === 'json' ? (0, stream_1.createJsonStream)() : (0, stream_1.createCsvStream)(columns);
+        (async () => {
+            let page = 1;
+            let hasMore = true;
+            try {
+                while (hasMore) {
+                    const r = await ctx.db.getRows(table, { limit: chunkSize, page, filters: options.filters });
+                    if (!r.success) {
+                        transform.destroy(new Error(r.error ?? 'Failed to stream rows.'));
+                        return;
+                    }
+                    const rows = (r.data ?? []);
+                    if (rows.length === 0) {
+                        hasMore = false;
+                        break;
+                    }
+                    for (const row of rows) {
+                        transform.write((0, common_1.normalizeRow)(row));
+                    }
+                    if (rows.length < chunkSize) {
+                        hasMore = false;
+                    }
+                    else {
+                        page++;
+                    }
+                }
+                transform.end();
+            }
+            catch (err) {
+                transform.destroy(err);
+            }
+        })();
+        const contentType = options.format === 'json' ? 'application/json; charset=utf-8' : 'text/csv; charset=utf-8';
+        const filename = `${table}.${options.format}`;
+        return { stream: transform, contentType, filename };
+    }
+    static async exportBulkRows(ctx, table, info, wheres, format) {
+        const rowsR = await ctx.db.getRowsByPks(table, wheres);
+        if (!rowsR.success)
+            throw new Error(rowsR.error ?? 'Failed to load rows.');
+        const rows = (rowsR.data ?? []).map(common_1.normalizeRow);
+        const columns = info.columns.map((c) => c.name);
+        if (format === 'json') {
+            return { data: (0, csv_1.toJson)(rows), contentType: 'application/json; charset=utf-8', filename: `${table}_selected.json` };
+        }
+        return { data: (0, csv_1.toCsv)(rows, columns), contentType: 'text/csv; charset=utf-8', filename: `${table}_selected.csv` };
+    }
+    static async importCsv(ctx, table, info, csvText) {
+        if (!csvText.trim())
+            throw new Error('No CSV data provided.');
+        const parsed = (0, csv_1.parseCsv)(csvText);
+        if (!parsed.length)
+            throw new Error('CSV file is empty.');
+        const header = parsed[0].map((h) => h.trim());
+        const typeMap = new Map(info.columns.map((c) => [c.name, c.type]));
+        const validCols = header.filter((h) => typeMap.has(h));
+        if (!validCols.length) {
+            throw new Error('None of the CSV columns match columns in this table.');
+        }
+        const rows = parsed.slice(1).map((line) => {
+            const fields = [];
+            for (let i = 0; i < header.length; i++) {
+                const col = header[i];
+                if (!typeMap.has(col))
+                    continue;
+                fields.push({ column: col, value: (0, common_1.coerceFormValue)(line[i] ?? '', typeMap.get(col)) });
+            }
+            return fields;
+        });
+        const r = await ctx.db.insertRows(table, rows);
+        if (!r.success)
+            throw new Error(r.error ?? 'Failed to import CSV.');
+        return r.data?.inserted ?? 0;
+    }
+    static async streamImportCsv(ctx, table, info, csvStream, batchSize = 500) {
+        const typeMap = new Map(info.columns.map((c) => [c.name, c.type]));
+        let header = null;
+        let totalInserted = 0;
+        await (0, stream_1.parseCsvStreamBatched)(csvStream, async (batch) => {
+            let dataRows = batch;
+            if (!header) {
+                if (batch.length === 0)
+                    return;
+                header = batch[0].map((h) => h.trim());
+                dataRows = batch.slice(1);
+            }
+            if (dataRows.length === 0)
+                return;
+            const validColIndices = header
+                .map((col, idx) => (typeMap.has(col) ? idx : -1))
+                .filter((idx) => idx !== -1);
+            if (!validColIndices.length) {
+                throw new Error('None of the CSV columns match columns in this table.');
+            }
+            const rowsToInsert = dataRows.map((line) => {
+                const fields = [];
+                for (const i of validColIndices) {
+                    const col = header[i];
+                    fields.push({ column: col, value: (0, common_1.coerceFormValue)(line[i] ?? '', typeMap.get(col)) });
+                }
+                return fields;
+            });
+            const r = await ctx.db.insertRows(table, rowsToInsert);
+            if (!r.success)
+                throw new Error(r.error ?? 'Failed to import CSV batch.');
+            totalInserted += r.data?.inserted ?? rowsToInsert.length;
+        }, batchSize);
+        return totalInserted;
+    }
+}
+exports.RowsService = RowsService;

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

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

package/dist/modules/schema/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("./schema.service"), exports);
+__exportStar(require("./schema.routes"), exports);

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

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

package/dist/modules/schema/schema.routes.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSchemaRoutes = registerSchemaRoutes;
+const router_1 = require("../../core/router");
+const tables_service_1 = require("../tables/tables.service");
+const schema_service_1 = require("./schema.service");
+function registerSchemaRoutes(router, ctx) {
+    router.get('/schema/:db/:table', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            const table = req.params.table;
+            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);
+            const [info, schema] = await Promise.all([
+                tables_service_1.TableService.getTableInfo(db, table),
+                schema_service_1.SchemaService.getSchema(db, table),
+            ]);
+            if (!info) {
+                return (0, router_1.notFound)(res, `Table "${table}" does not exist.`);
+            }
+            res.locals.currentTable = table;
+            res.render('pages/schema', {
+                title: `Schema · ${table}`,
+                dbId,
+                table,
+                schema,
+                isInternal: table.startsWith('_'),
+                dialect: db.dialect.name,
+                isSqlite: db.dialect.name === 'sqlite',
+                isPostgres: db.dialect.name === 'postgres',
+                config: { dbId, table, isInternal: table.startsWith('_'), dialect: db.dialect.name },
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/designer/: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/designer', {
+                title: 'New table',
+                dbId,
+                dialect: db.dialect.name,
+                isSqlite: db.dialect.name === 'sqlite',
+                isPostgres: db.dialect.name === 'postgres',
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/designer/:db/:table', async (req, res, next) => {
+        try {
+            const db = ctx.getContext(req);
+            const dbId = req.params.db;
+            const table = req.params.table;
+            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);
+            const [info, schema] = await Promise.all([
+                tables_service_1.TableService.getTableInfo(db, table),
+                schema_service_1.SchemaService.getSchema(db, table),
+            ]);
+            if (!info) {
+                return (0, router_1.notFound)(res, `Table "${table}" does not exist.`);
+            }
+            res.locals.currentTable = table;
+            res.render('pages/designer', {
+                title: `Edit table · ${table}`,
+                dbId,
+                table,
+                info,
+                schema,
+                dialect: db.dialect.name,
+                isSqlite: db.dialect.name === 'sqlite',
+                isPostgres: db.dialect.name === 'postgres',
+            });
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+    router.get('/api/tables/:db/:table/schema', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const schema = await schema_service_1.SchemaService.getSchema(db, req.params.table);
+        (0, router_1.ok)(res, schema);
+    }));
+    router.post('/api/tables/:db/:table/columns', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const col = req.body;
+        if (!col?.name)
+            return (0, router_1.fail)(res, 'Column name is required.');
+        try {
+            await schema_service_1.SchemaService.addColumn(db, req.params.table, col);
+            (0, router_1.ok)(res, { message: `Column "${col.name}" added.` }, 201);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to add column.');
+        }
+    }));
+    router.put('/api/tables/:db/:table/columns/:column', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const col = req.body;
+        if (!col)
+            return (0, router_1.fail)(res, 'Column definition is required.');
+        try {
+            await schema_service_1.SchemaService.modifyColumn(db, req.params.table, req.params.column, col);
+            (0, router_1.ok)(res, { message: `Column "${req.params.column}" updated.` });
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to modify column.');
+        }
+    }));
+    router.post('/api/tables/:db/:table/columns/:column/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 column name is required.');
+        try {
+            await schema_service_1.SchemaService.renameColumn(db, req.params.table, req.params.column, newName);
+            (0, router_1.ok)(res, { message: `Column renamed to "${newName}".`, name: newName });
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to rename column.');
+        }
+    }));
+    router.delete('/api/tables/:db/:table/columns/:column', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        try {
+            await schema_service_1.SchemaService.dropColumn(db, req.params.table, req.params.column);
+            (0, router_1.ok)(res, { message: `Column "${req.params.column}" dropped.` });
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to drop column.');
+        }
+    }));
+    router.post('/api/tables/:db/:table/indexes', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        const def = req.body;
+        if (!def || !Array.isArray(def.columns) || def.columns.length === 0) {
+            return (0, router_1.fail)(res, 'At least one column is required for an index.');
+        }
+        try {
+            await schema_service_1.SchemaService.createIndex(db, req.params.table, def);
+            (0, router_1.ok)(res, { message: 'Index created.' }, 201);
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to create index.');
+        }
+    }));
+    router.delete('/api/tables/:db/:table/indexes/:index', (0, router_1.wrap)(async (req, res) => {
+        const db = ctx.getContext(req);
+        try {
+            await schema_service_1.SchemaService.dropIndex(db, req.params.index);
+            (0, router_1.ok)(res, { message: `Index "${req.params.index}" dropped.` });
+        }
+        catch (err) {
+            (0, router_1.fail)(res, err.message ?? 'Failed to drop index.');
+        }
+    }));
+}

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

@@ -0,0 +1 @@
+import type {ReferencingTableInfo,SchemaInfo} from '../../db/index';import type {DatabaseContext} from '../../core/context';import type {ColumnDef,IndexDef} from '../../sql/generator';export declare class SchemaService{static getSchema(ctx:DatabaseContext,table:string):Promise<SchemaInfo>;static getReferencingTables(ctx:DatabaseContext,table:string):Promise<ReferencingTableInfo[]>;static addColumn(ctx:DatabaseContext,table:string,col:ColumnDef):Promise<void>;static modifyColumn(ctx:DatabaseContext,table:string,colName:string,col:ColumnDef):Promise<void>;static renameColumn(ctx:DatabaseContext,table:string,colName:string,newName:string):Promise<void>;static dropColumn(ctx:DatabaseContext,table:string,colName:string):Promise<void>;static createIndex(ctx:DatabaseContext,table:string,def:IndexDef):Promise<void>;static dropIndex(ctx:DatabaseContext,indexName:string):Promise<void>;}