flex-mcp 1.0.0

package/dist/api/tables.js

@@ -0,0 +1,702 @@
+/**
+ * 表管理 API
+ */
+import { Hono } from 'hono';
+import { authMiddleware, getCurrentUserId, getCurrentUserRole } from './middleware.js';
+import { db } from '../db/index.js';
+import { tableDefinitions, tableData } from '../db/schema.js';
+import { eq, and } from 'drizzle-orm';
+import { generateId } from '../utils/id.js';
+import { report } from '../utils/telemetry.js';
+export const tablesRouter = new Hono();
+// 所有路由需要认证
+tablesRouter.use('*', authMiddleware);
+// 中间件：禁止超级管理员访问数据管理功能
+tablesRouter.use('*', async (c, next) => {
+    const currentRole = getCurrentUserRole(c);
+    if (currentRole === 'admin') {
+        return c.json({ success: false, error: '超级管理员不允许访问数据管理功能' }, 403);
+    }
+    await next();
+});
+// 获取当前用户的所有表定义列表
+tablesRouter.get('/definitions', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const result = await db
+            .select()
+            .from(tableDefinitions)
+            .where(eq(tableDefinitions.userId, userId));
+        const tables = result.map((row) => ({
+            id: row.id,
+            name: row.name,
+            description: row.description || undefined,
+            columns: JSON.parse(row.columns),
+            allowExplore: row.allowExplore !== undefined ? Boolean(row.allowExplore) : true, // 默认为 true
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        }));
+        return c.json({ success: true, data: tables });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 获取单个表定义（仅限当前用户）
+tablesRouter.get('/definitions/:id', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const tableId = c.req.param('id');
+        const result = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.id, tableId), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (result.length === 0) {
+            return c.json({ success: false, error: 'Table definition not found' }, 404);
+        }
+        const row = result[0];
+        const table = {
+            id: row.id,
+            name: row.name,
+            description: row.description || undefined,
+            columns: JSON.parse(row.columns),
+            allowExplore: row.allowExplore !== undefined ? Boolean(row.allowExplore) : true, // 默认为 true
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        return c.json({ success: true, data: table });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 创建表定义（当前用户）
+tablesRouter.post('/definitions', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const body = await c.req.json();
+        const { name, description, columns, allowExplore } = body;
+        if (!name || !columns || !Array.isArray(columns) || columns.length === 0) {
+            return c.json({ success: false, error: 'Name and columns are required' }, 400);
+        }
+        // 验证列定义
+        for (const col of columns) {
+            if (!col.name || !col.type) {
+                return c.json({ success: false, error: 'Each column must have name and type' }, 400);
+            }
+            if (!['string', 'number', 'boolean', 'date', 'json'].includes(col.type)) {
+                return c.json({ success: false, error: `Invalid column type: ${col.type}` }, 400);
+            }
+        }
+        // 检查当前用户的表名是否已存在
+        const existing = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.name, name), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (existing.length > 0) {
+            return c.json({ success: false, error: 'Table with this name already exists' }, 400);
+        }
+        const tableId = generateId();
+        const now = new Date();
+        await db.insert(tableDefinitions).values({
+            id: tableId,
+            userId,
+            name,
+            description: description || null,
+            columns: JSON.stringify(columns),
+            allowExplore: allowExplore !== undefined ? allowExplore : true, // 默认为 true
+            createdAt: now,
+            updatedAt: now,
+        });
+        // 上报表创建统计
+        report('table_created', {
+            columns_count: columns.length,
+            allow_explore: allowExplore !== false,
+        }, userId);
+        const result = await db
+            .select()
+            .from(tableDefinitions)
+            .where(eq(tableDefinitions.id, tableId))
+            .limit(1);
+        const row = result[0];
+        const table = {
+            id: row.id,
+            name: row.name,
+            description: row.description || undefined,
+            columns: JSON.parse(row.columns),
+            allowExplore: row.allowExplore !== undefined ? Boolean(row.allowExplore) : true, // 默认为 true
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        return c.json({ success: true, data: table }, 201);
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 更新表定义（仅限当前用户）
+tablesRouter.put('/definitions/:id', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const tableId = c.req.param('id');
+        const body = await c.req.json();
+        const existing = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.id, tableId), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (existing.length === 0) {
+            return c.json({ success: false, error: 'Table definition not found' }, 404);
+        }
+        // 如果表名改变，检查当前用户的新表名是否已存在
+        if (body.name && body.name !== existing[0].name) {
+            const nameExists = await db
+                .select()
+                .from(tableDefinitions)
+                .where(and(eq(tableDefinitions.name, body.name), eq(tableDefinitions.userId, userId)))
+                .limit(1);
+            if (nameExists.length > 0) {
+                return c.json({ success: false, error: 'Table with this name already exists' }, 400);
+            }
+        }
+        // 如果列定义改变，验证列定义
+        if (body.columns) {
+            if (!Array.isArray(body.columns) || body.columns.length === 0) {
+                return c.json({ success: false, error: 'Columns must be a non-empty array' }, 400);
+            }
+            for (const col of body.columns) {
+                if (!col.name || !col.type) {
+                    return c.json({ success: false, error: 'Each column must have name and type' }, 400);
+                }
+                if (!['string', 'number', 'boolean', 'date', 'json'].includes(col.type)) {
+                    return c.json({ success: false, error: `Invalid column type: ${col.type}` }, 400);
+                }
+            }
+        }
+        await db
+            .update(tableDefinitions)
+            .set({
+            name: body.name,
+            description: body.description !== undefined ? body.description : null,
+            columns: body.columns ? JSON.stringify(body.columns) : undefined,
+            allowExplore: body.allowExplore !== undefined ? body.allowExplore : undefined,
+            updatedAt: new Date(),
+        })
+            .where(eq(tableDefinitions.id, tableId));
+        const result = await db
+            .select()
+            .from(tableDefinitions)
+            .where(eq(tableDefinitions.id, tableId))
+            .limit(1);
+        const row = result[0];
+        const table = {
+            id: row.id,
+            name: row.name,
+            description: row.description || undefined,
+            columns: JSON.parse(row.columns),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        return c.json({ success: true, data: table });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 删除表定义（仅限当前用户，会级联删除所有数据）
+tablesRouter.delete('/definitions/:id', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const tableId = c.req.param('id');
+        const existing = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.id, tableId), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (existing.length === 0) {
+            return c.json({ success: false, error: 'Table definition not found' }, 404);
+        }
+        await db.delete(tableDefinitions).where(eq(tableDefinitions.id, tableId));
+        return c.json({ success: true, message: 'Table definition deleted' });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 获取表的所有数据（仅限当前用户的表）
+tablesRouter.get('/data/:tableId', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const tableId = c.req.param('tableId');
+        // 验证表定义是否存在且属于当前用户
+        const tableDef = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.id, tableId), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (tableDef.length === 0) {
+            return c.json({ success: false, error: 'Table definition not found' }, 404);
+        }
+        const result = await db
+            .select()
+            .from(tableData)
+            .where(eq(tableData.tableId, tableId));
+        const rows = result.map((row) => ({
+            id: row.id,
+            tableId: row.tableId,
+            rowData: JSON.parse(row.rowData),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        }));
+        return c.json({ success: true, data: rows });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 创建表数据行（仅限当前用户的表）
+tablesRouter.post('/data/:tableId', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const tableId = c.req.param('tableId');
+        const body = await c.req.json();
+        // 验证表定义是否存在且属于当前用户
+        const tableDef = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.id, tableId), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (tableDef.length === 0) {
+            return c.json({ success: false, error: 'Table definition not found' }, 404);
+        }
+        const columns = JSON.parse(tableDef[0].columns);
+        // 验证数据是否符合列定义
+        const validatedData = {};
+        for (const col of columns) {
+            const value = body.rowData[col.name];
+            if (value === undefined || value === null) {
+                if (col.nullable) {
+                    validatedData[col.name] = null;
+                }
+                else if (col.defaultValue !== undefined) {
+                    validatedData[col.name] = col.defaultValue;
+                }
+                else {
+                    return c.json({ success: false, error: `Column ${col.name} is required` }, 400);
+                }
+            }
+            else {
+                // 类型转换和验证
+                validatedData[col.name] = convertValue(value, col.type);
+            }
+        }
+        const rowId = generateId();
+        const now = new Date();
+        await db.insert(tableData).values({
+            id: rowId,
+            tableId,
+            rowData: JSON.stringify(validatedData),
+            createdAt: now,
+            updatedAt: now,
+        });
+        const result = await db
+            .select()
+            .from(tableData)
+            .where(eq(tableData.id, rowId))
+            .limit(1);
+        const row = result[0];
+        const tableRow = {
+            id: row.id,
+            tableId: row.tableId,
+            rowData: JSON.parse(row.rowData),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        return c.json({ success: true, data: tableRow }, 201);
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 批量更新表数据（用于 Excel 式的批量编辑，仅限当前用户的表）
+// 注意：这个路由必须在 /data/:tableId/:rowId 之前定义，否则会被误匹配
+tablesRouter.put('/data/:tableId/batch', async (c) => {
+    console.log('批量导入请求:', {
+        method: c.req.method,
+        path: c.req.path,
+        tableId: c.req.param('tableId'),
+        userId: getCurrentUserId(c),
+    });
+    try {
+        const userId = getCurrentUserId(c);
+        const tableId = c.req.param('tableId');
+        const body = await c.req.json();
+        console.log('批量导入请求体:', {
+            rowsCount: body.rows?.length,
+            sampleRow: body.rows?.[0],
+            hasIds: body.rows?.some(r => r.id !== undefined),
+        });
+        // 验证表定义是否存在且属于当前用户
+        const tableDef = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.id, tableId), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (tableDef.length === 0) {
+            console.error('批量导入失败：表定义不存在', {
+                tableId,
+                userId,
+                requestPath: c.req.path,
+                requestMethod: c.req.method,
+            });
+            return c.json({
+                success: false,
+                error: `Table definition not found for tableId: ${tableId}. Please check if the table exists and belongs to the current user.`
+            }, 404);
+        }
+        const columns = JSON.parse(tableDef[0].columns);
+        console.log('批量导入：表定义验证通过', {
+            tableId,
+            userId,
+            columnsCount: columns.length,
+            tableName: tableDef[0].name,
+        });
+        const now = new Date();
+        const results = [];
+        // 处理每一行
+        for (const rowInput of body.rows) {
+            // 调试日志
+            if (rowInput.id) {
+                console.log(`批量导入：检测到 id 字段 ${rowInput.id}，将尝试更新现有行`);
+            }
+            if (rowInput.id) {
+                // 更新现有行
+                const existingRow = await db
+                    .select()
+                    .from(tableData)
+                    .where(and(eq(tableData.id, rowInput.id), eq(tableData.tableId, tableId)))
+                    .limit(1);
+                if (existingRow.length > 0) {
+                    const currentData = JSON.parse(existingRow[0].rowData);
+                    const validatedData = { ...currentData };
+                    for (const col of columns) {
+                        if (Object.prototype.hasOwnProperty.call(rowInput.rowData, col.name)) {
+                            const value = rowInput.rowData[col.name];
+                            if (value === undefined || value === null) {
+                                if (col.nullable) {
+                                    validatedData[col.name] = null;
+                                }
+                                else if (col.defaultValue !== undefined) {
+                                    validatedData[col.name] = col.defaultValue;
+                                }
+                            }
+                            else {
+                                validatedData[col.name] = convertValue(value, col.type);
+                            }
+                        }
+                    }
+                    await db
+                        .update(tableData)
+                        .set({
+                        rowData: JSON.stringify(validatedData),
+                        updatedAt: now,
+                    })
+                        .where(eq(tableData.id, rowInput.id));
+                    const updated = await db
+                        .select()
+                        .from(tableData)
+                        .where(eq(tableData.id, rowInput.id))
+                        .limit(1);
+                    if (updated.length === 0) {
+                        throw new Error(`Failed to retrieve updated row with id: ${rowInput.id}`);
+                    }
+                    results.push({
+                        id: updated[0].id,
+                        tableId: updated[0].tableId,
+                        rowData: JSON.parse(updated[0].rowData),
+                        createdAt: updated[0].createdAt,
+                        updatedAt: updated[0].updatedAt,
+                    });
+                }
+                else {
+                    // 行不存在，但提供了id，可能是数据不同步，创建新行
+                    const validatedData = {};
+                    for (const col of columns) {
+                        const value = rowInput.rowData[col.name];
+                        if (value === undefined || value === null) {
+                            if (col.nullable) {
+                                validatedData[col.name] = null;
+                            }
+                            else if (col.defaultValue !== undefined) {
+                                validatedData[col.name] = col.defaultValue;
+                            }
+                            else {
+                                // 必填字段缺失，使用默认值
+                                switch (col.type) {
+                                    case 'string':
+                                        validatedData[col.name] = '';
+                                        break;
+                                    case 'number':
+                                        validatedData[col.name] = 0;
+                                        break;
+                                    case 'boolean':
+                                        validatedData[col.name] = false;
+                                        break;
+                                    case 'date':
+                                        validatedData[col.name] = new Date().toISOString();
+                                        break;
+                                    case 'json':
+                                        validatedData[col.name] = {};
+                                        break;
+                                }
+                            }
+                        }
+                        else {
+                            validatedData[col.name] = convertValue(value, col.type);
+                        }
+                    }
+                    const rowId = generateId();
+                    await db.insert(tableData).values({
+                        id: rowId,
+                        tableId,
+                        rowData: JSON.stringify(validatedData),
+                        createdAt: now,
+                        updatedAt: now,
+                    });
+                    const newRow = await db
+                        .select()
+                        .from(tableData)
+                        .where(eq(tableData.id, rowId))
+                        .limit(1);
+                    if (newRow.length === 0) {
+                        throw new Error(`Failed to retrieve newly created row with id: ${rowId}`);
+                    }
+                    results.push({
+                        id: newRow[0].id,
+                        tableId: newRow[0].tableId,
+                        rowData: JSON.parse(newRow[0].rowData),
+                        createdAt: newRow[0].createdAt,
+                        updatedAt: newRow[0].updatedAt,
+                    });
+                }
+            }
+            else {
+                // 创建新行
+                const validatedData = {};
+                for (const col of columns) {
+                    const value = rowInput.rowData[col.name];
+                    if (value === undefined || value === null) {
+                        if (col.nullable) {
+                            validatedData[col.name] = null;
+                        }
+                        else if (col.defaultValue !== undefined) {
+                            validatedData[col.name] = col.defaultValue;
+                        }
+                        else {
+                            // 必填字段缺失，使用默认值而不是跳过
+                            switch (col.type) {
+                                case 'string':
+                                    validatedData[col.name] = '';
+                                    break;
+                                case 'number':
+                                    validatedData[col.name] = 0;
+                                    break;
+                                case 'boolean':
+                                    validatedData[col.name] = false;
+                                    break;
+                                case 'date':
+                                    validatedData[col.name] = new Date().toISOString();
+                                    break;
+                                case 'json':
+                                    validatedData[col.name] = {};
+                                    break;
+                            }
+                        }
+                    }
+                    else {
+                        validatedData[col.name] = convertValue(value, col.type);
+                    }
+                }
+                const rowId = generateId();
+                await db.insert(tableData).values({
+                    id: rowId,
+                    tableId,
+                    rowData: JSON.stringify(validatedData),
+                    createdAt: now,
+                    updatedAt: now,
+                });
+                const newRow = await db
+                    .select()
+                    .from(tableData)
+                    .where(eq(tableData.id, rowId))
+                    .limit(1);
+                if (newRow.length === 0) {
+                    throw new Error(`Failed to retrieve newly created row with id: ${rowId}`);
+                }
+                results.push({
+                    id: newRow[0].id,
+                    tableId: newRow[0].tableId,
+                    rowData: JSON.parse(newRow[0].rowData),
+                    createdAt: newRow[0].createdAt,
+                    updatedAt: newRow[0].updatedAt,
+                });
+            }
+        }
+        return c.json({ success: true, data: results });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 更新表数据行（仅限当前用户的表）
+tablesRouter.put('/data/:tableId/:rowId', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const tableId = c.req.param('tableId');
+        const rowId = c.req.param('rowId');
+        const body = await c.req.json();
+        // 验证表定义是否存在且属于当前用户
+        const tableDef = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.id, tableId), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (tableDef.length === 0) {
+            return c.json({ success: false, error: 'Table definition not found' }, 404);
+        }
+        // 验证行是否存在
+        const existingRow = await db
+            .select()
+            .from(tableData)
+            .where(and(eq(tableData.id, rowId), eq(tableData.tableId, tableId)))
+            .limit(1);
+        if (existingRow.length === 0) {
+            return c.json({ success: false, error: 'Row not found' }, 404);
+        }
+        const columns = JSON.parse(tableDef[0].columns);
+        const currentData = JSON.parse(existingRow[0].rowData);
+        // 合并并验证数据
+        const validatedData = { ...currentData };
+        for (const col of columns) {
+            if (Object.prototype.hasOwnProperty.call(body.rowData, col.name)) {
+                const value = body.rowData[col.name];
+                if (value === undefined || value === null) {
+                    if (col.nullable) {
+                        validatedData[col.name] = null;
+                    }
+                    else if (col.defaultValue !== undefined) {
+                        validatedData[col.name] = col.defaultValue;
+                    }
+                    else {
+                        return c.json({ success: false, error: `Column ${col.name} cannot be null` }, 400);
+                    }
+                }
+                else {
+                    validatedData[col.name] = convertValue(value, col.type);
+                }
+            }
+        }
+        await db
+            .update(tableData)
+            .set({
+            rowData: JSON.stringify(validatedData),
+            updatedAt: new Date(),
+        })
+            .where(eq(tableData.id, rowId));
+        const result = await db
+            .select()
+            .from(tableData)
+            .where(eq(tableData.id, rowId))
+            .limit(1);
+        const row = result[0];
+        const tableRow = {
+            id: row.id,
+            tableId: row.tableId,
+            rowData: JSON.parse(row.rowData),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        return c.json({ success: true, data: tableRow });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 删除表数据行（仅限当前用户的表）
+tablesRouter.delete('/data/:tableId/:rowId', async (c) => {
+    try {
+        const userId = getCurrentUserId(c);
+        const tableId = c.req.param('tableId');
+        const rowId = c.req.param('rowId');
+        // 先验证表是否属于当前用户
+        const tableDef = await db
+            .select()
+            .from(tableDefinitions)
+            .where(and(eq(tableDefinitions.id, tableId), eq(tableDefinitions.userId, userId)))
+            .limit(1);
+        if (tableDef.length === 0) {
+            return c.json({ success: false, error: 'Table definition not found' }, 404);
+        }
+        const existing = await db
+            .select()
+            .from(tableData)
+            .where(and(eq(tableData.id, rowId), eq(tableData.tableId, tableId)))
+            .limit(1);
+        if (existing.length === 0) {
+            return c.json({ success: false, error: 'Row not found' }, 404);
+        }
+        await db.delete(tableData).where(eq(tableData.id, rowId));
+        return c.json({ success: true, message: 'Row deleted' });
+    }
+    catch (error) {
+        return c.json({ success: false, error: error.message }, 500);
+    }
+});
+// 辅助函数：类型转换
+function convertValue(value, type) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    switch (type) {
+        case 'string':
+            return String(value);
+        case 'number':
+            return Number(value);
+        case 'boolean':
+            if (typeof value === 'boolean') {
+                return value;
+            }
+            if (typeof value === 'string') {
+                return value.toLowerCase() === 'true' || value === '1';
+            }
+            return Boolean(value);
+        case 'date': {
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            if (typeof value === 'string' || typeof value === 'number') {
+                const date = new Date(value);
+                if (isNaN(date.getTime())) {
+                    throw new Error(`Cannot convert "${value}" to date`);
+                }
+                return date.toISOString();
+            }
+            throw new Error(`Cannot convert "${value}" to date`);
+        }
+        case 'json':
+            if (typeof value === 'string') {
+                try {
+                    return JSON.parse(value);
+                }
+                catch {
+                    return value;
+                }
+            }
+            return value;
+        default:
+            return value;
+    }
+}
+//# sourceMappingURL=tables.js.map