befly 3.0.0 → 3.0.1

package/checks/conflict.ts

@@ -5,9 +5,9 @@
 
 import path from 'node:path';
 import { Logger } from '../utils/logger.js';
-import { scanAddons, getAddonDir, hasAddonDir } from '../utils/addonHelper.js';
-import { __dirtables, __dirapis, __dirplugins, getProjectDir } from '../system.js';
-import { isReservedTableName, isReservedRoute, isReservedPluginName, isReservedAddonName, getReservedTablePrefixes, getReservedRoutes, getReservedPlugins, getReservedAddonNames } from '../config/reserved.js';
+import { paths } from '../paths.js';
+import { scanAddons, getAddonDir, addonDirExists } from '../utils/helper.js';
+import { isReservedTableName, isReservedPluginName, isReservedAddonName, getReservedTablePrefixes, getReservedPlugins, getReservedAddonNames } from '../config/reserved.js';
 
 /**
  * 资源注册表
@@ -26,73 +26,6 @@ interface ConflictResult {
     conflicts: string[];
 }
 
-/**
- * 收集核心表定义
- */
-async function collectCoreTables(registry: ResourceRegistry): Promise<void> {
-    try {
-        const glob = new Bun.Glob('*.json');
-        for await (const file of glob.scan({
-            cwd: __dirtables,
-            onlyFiles: true,
-            absolute: true
-        })) {
-            const fileName = path.basename(file, '.json');
-            if (fileName.startsWith('_')) continue;
-
-            try {
-                const tableDefine = await Bun.file(file).json();
-                const tableName = tableDefine.tableName || `sys_${fileName}`;
-
-                if (registry.tables.has(tableName)) {
-                    Logger.error(`核心表 "${tableName}" 重复定义`);
-                } else {
-                    registry.tables.set(tableName, 'core');
-                }
-            } catch (error: any) {
-                // 表定义解析错误会在 table.ts 中处理，这里跳过
-            }
-        }
-    } catch (error: any) {
-        Logger.error('收集核心表定义时出错:', error);
-    }
-}
-
-/**
- * 收集核心 API 路由
- */
-async function collectCoreApis(registry: ResourceRegistry): Promise<void> {
-    try {
-        const glob = new Bun.Glob('**/*.ts');
-        for await (const file of glob.scan({
-            cwd: __dirapis,
-            onlyFiles: true,
-            absolute: true
-        })) {
-            const apiPath = path
-                .relative(__dirapis, file)
-                .replace(/\.(js|ts)$/, '')
-                .replace(/\\/g, '/');
-            if (apiPath.indexOf('_') !== -1) continue;
-
-            try {
-                const api = (await import(file)).default;
-                const route = `${(api.method || 'POST').toUpperCase()}/api/${apiPath}`;
-
-                if (registry.routes.has(route)) {
-                    Logger.error(`核心路由 "${route}" 重复定义`);
-                } else {
-                    registry.routes.set(route, 'core');
-                }
-            } catch (error: any) {
-                // API 加载错误会在 loader.ts 中处理，这里跳过
-            }
-        }
-    } catch (error: any) {
-        Logger.error('收集核心 API 路由时出错:', error);
-    }
-}
-
 /**
  * 收集核心插件
  */
@@ -100,15 +33,15 @@ async function collectCorePlugins(registry: ResourceRegistry): Promise<void> {
     try {
         const glob = new Bun.Glob('*.ts');
         for await (const file of glob.scan({
-            cwd: __dirplugins,
+            cwd: paths.rootPluginDir,
             onlyFiles: true,
             absolute: true
         })) {
-            const pluginName = path.basename(file).replace(/\.(js|ts)$/, '');
+            const pluginName = path.basename(file).replace(/\.ts$/, '');
             if (pluginName.startsWith('_')) continue;
 
             if (registry.plugins.has(pluginName)) {
-                Logger.error(`核心插件 "${pluginName}" 重复定义`);
+                Logger.warn(`核心插件 "${pluginName}" 重复定义`);
             } else {
                 registry.plugins.set(pluginName, 'core');
             }
@@ -126,12 +59,12 @@ async function collectAddonResources(addonName: string, registry: ResourceRegist
 
     // 检查 addon 名称是否使用保留名称
     if (isReservedAddonName(addonName)) {
-        conflicts.push(`Addon 名称 "${addonName}" 使用了保留名称，保留名称包括: ${getReservedAddonNames().join(', ')}`);
+        conflicts.push(`组件名称 "${addonName}" 使用了保留名称，保留名称包括: ${getReservedAddonNames().join(', ')}`);
         return conflicts;
     }
 
     // 收集 addon 表定义
-    if (hasAddonDir(addonName, 'tables')) {
+    if (addonDirExists(addonName, 'tables')) {
         const addonTablesDir = getAddonDir(addonName, 'tables');
         const glob = new Bun.Glob('*.json');
 
@@ -149,15 +82,15 @@ async function collectAddonResources(addonName: string, registry: ResourceRegist
 
                 // 检查是否使用保留前缀
                 if (isReservedTableName(tableName)) {
-                    conflicts.push(`Addon [${addonName}] 表 "${tableName}" 使用了保留前缀，保留前缀包括: ${getReservedTablePrefixes().join(', ')}`);
+                    conflicts.push(`组件 ${addonName} 表 "${tableName}" 使用了保留前缀，保留前缀包括: ${getReservedTablePrefixes().join(', ')}`);
                     continue;
                 }
 
                 // 检查是否与已有表冲突
                 if (registry.tables.has(tableName)) {
-                    conflicts.push(`Addon [${addonName}] 表 "${tableName}" 与 ${registry.tables.get(tableName)} 冲突`);
+                    conflicts.push(`组件 ${addonName} 表 "${tableName}" 与 ${registry.tables.get(tableName)} 冲突`);
                 } else {
-                    registry.tables.set(tableName, `addon[${addonName}]`);
+                    registry.tables.set(tableName, `组件${addonName}`);
                 }
             } catch (error: any) {
                 // 表定义解析错误会在 table.ts 中处理，这里跳过
@@ -166,7 +99,7 @@ async function collectAddonResources(addonName: string, registry: ResourceRegist
     }
 
     // 收集 addon API 路由
-    if (hasAddonDir(addonName, 'apis')) {
+    if (addonDirExists(addonName, 'apis')) {
         const addonApisDir = getAddonDir(addonName, 'apis');
         const glob = new Bun.Glob('**/*.ts');
 
@@ -175,27 +108,24 @@ async function collectAddonResources(addonName: string, registry: ResourceRegist
             onlyFiles: true,
             absolute: true
         })) {
-            const apiPath = path
-                .relative(addonApisDir, file)
-                .replace(/\.(js|ts)$/, '')
-                .replace(/\\/g, '/');
+            const apiPath = path.relative(addonApisDir, file).replace(/\.ts$/, '').replace(/\\/g, '/');
             if (apiPath.indexOf('_') !== -1) continue;
 
             try {
                 const api = (await import(file)).default;
                 const route = `${(api.method || 'POST').toUpperCase()}/api/${addonName}/${apiPath}`;
 
-                // 检查是否使用保留路由
-                if (isReservedRoute(route)) {
-                    conflicts.push(`Addon [${addonName}] 路由 "${route}" 使用了保留路径，保留路径包括: ${getReservedRoutes().join(', ')}`);
+                // 检查是否使用保留路由前缀 /api
+                if (route.includes('/api/api/') || route.includes('/api/api')) {
+                    conflicts.push(`组件 [${addonName}] 路由 "${route}" 使用了保留路径前缀 "/api"`);
                     continue;
                 }
 
                 // 检查是否与已有路由冲突
                 if (registry.routes.has(route)) {
-                    conflicts.push(`Addon [${addonName}] 路由 "${route}" 与 ${registry.routes.get(route)} 冲突`);
+                    conflicts.push(`组件 [${addonName}] 路由 "${route}" 与 ${registry.routes.get(route)} 冲突`);
                 } else {
-                    registry.routes.set(route, `addon[${addonName}]`);
+                    registry.routes.set(route, `组件${addonName}`);
                 }
             } catch (error: any) {
                 // API 加载错误会在 loader.ts 中处理，这里跳过
@@ -204,7 +134,7 @@ async function collectAddonResources(addonName: string, registry: ResourceRegist
     }
 
     // 收集 addon 插件
-    if (hasAddonDir(addonName, 'plugins')) {
+    if (addonDirExists(addonName, 'plugins')) {
         const addonPluginsDir = getAddonDir(addonName, 'plugins');
         const glob = new Bun.Glob('*.ts');
 
@@ -213,7 +143,7 @@ async function collectAddonResources(addonName: string, registry: ResourceRegist
             onlyFiles: true,
             absolute: true
         })) {
-            const fileName = path.basename(file).replace(/\.(js|ts)$/, '');
+            const fileName = path.basename(file).replace(/\.ts$/, '');
             if (fileName.startsWith('_')) continue;
 
             // Addon 插件使用点号命名空间
@@ -221,15 +151,15 @@ async function collectAddonResources(addonName: string, registry: ResourceRegist
 
             // 检查是否使用保留名称
             if (isReservedPluginName(pluginName)) {
-                conflicts.push(`Addon [${addonName}] 插件 "${pluginName}" 使用了保留名称，保留名称包括: ${getReservedPlugins().join(', ')}`);
+                conflicts.push(`组件 ${addonName} 插件 "${pluginName}" 使用了保留名称，保留名称包括: ${getReservedPlugins().join(', ')}`);
                 continue;
             }
 
             // 检查是否与已有插件冲突
             if (registry.plugins.has(pluginName)) {
-                conflicts.push(`Addon [${addonName}] 插件 "${pluginName}" 与 ${registry.plugins.get(pluginName)} 冲突`);
+                conflicts.push(`组件 [${addonName}] 插件 "${pluginName}" 与 ${registry.plugins.get(pluginName)} 冲突`);
             } else {
-                registry.plugins.set(pluginName, `addon[${addonName}]`);
+                registry.plugins.set(pluginName, `组件${addonName}`);
             }
         }
     }
@@ -244,7 +174,7 @@ async function collectUserResources(registry: ResourceRegistry): Promise<string[
     const conflicts: string[] = [];
 
     // 收集用户表定义
-    const userTablesDir = getProjectDir('tables');
+    const userTablesDir = paths.projectTableDir;
     try {
         const glob = new Bun.Glob('*.json');
         for await (const file of glob.scan({
@@ -280,7 +210,7 @@ async function collectUserResources(registry: ResourceRegistry): Promise<string[
     }
 
     // 收集用户 API 路由
-    const userApisDir = getProjectDir('apis');
+    const userApisDir = paths.projectApiDir;
     try {
         const glob = new Bun.Glob('**/*.ts');
         for await (const file of glob.scan({
@@ -288,19 +218,16 @@ async function collectUserResources(registry: ResourceRegistry): Promise<string[
             onlyFiles: true,
             absolute: true
         })) {
-            const apiPath = path
-                .relative(userApisDir, file)
-                .replace(/\.(js|ts)$/, '')
-                .replace(/\\/g, '/');
+            const apiPath = path.relative(userApisDir, file).replace(/\.ts$/, '').replace(/\\/g, '/');
             if (apiPath.indexOf('_') !== -1) continue;
 
             try {
                 const api = (await import(file)).default;
                 const route = `${(api.method || 'POST').toUpperCase()}/api/${apiPath}`;
 
-                // 检查是否使用保留路由
-                if (isReservedRoute(route)) {
-                    conflicts.push(`用户路由 "${route}" 使用了保留路径，保留路径包括: ${getReservedRoutes().join(', ')}`);
+                // 检查是否使用保留路由前缀 /api
+                if (apiPath.startsWith('api/') || apiPath === 'api') {
+                    conflicts.push(`用户路由 "${route}" 使用了保留路径前缀 "/api"`);
                     continue;
                 }
 
@@ -319,7 +246,7 @@ async function collectUserResources(registry: ResourceRegistry): Promise<string[
     }
 
     // 收集用户插件
-    const userPluginsDir = getProjectDir('plugins');
+    const userPluginsDir = paths.projectPluginDir;
     try {
         const glob = new Bun.Glob('*.ts');
         for await (const file of glob.scan({
@@ -327,7 +254,7 @@ async function collectUserResources(registry: ResourceRegistry): Promise<string[
             onlyFiles: true,
             absolute: true
         })) {
-            const pluginName = path.basename(file).replace(/\.(js|ts)$/, '');
+            const pluginName = path.basename(file).replace(/\.ts$/, '');
             if (pluginName.startsWith('_')) continue;
 
             // 检查是否使用保留名称
@@ -364,9 +291,7 @@ export default async function checkConflict(): Promise<boolean> {
 
         const allConflicts: string[] = [];
 
-        // 1. 收集核心资源
-        await collectCoreTables(registry);
-        await collectCoreApis(registry);
+        // 1. 收集核心插件
         await collectCorePlugins(registry);
 
         // 2. 收集 addon 资源
@@ -382,15 +307,11 @@ export default async function checkConflict(): Promise<boolean> {
 
         // 4. 报告冲突
         if (allConflicts.length > 0) {
-            Logger.error('');
-            Logger.error('❌ 检测到资源冲突:');
-            Logger.error('');
+            Logger.warn('检测到资源冲突:');
             allConflicts.forEach((conflict, index) => {
-                Logger.error(`  ${index + 1}. ${conflict}`);
+                Logger.warn(`  ${index + 1}. ${conflict}`);
             });
-            Logger.error('');
-            Logger.error('请解决以上冲突后再启动服务器');
-            Logger.error('');
+            Logger.warn('请解决以上冲突后再启动服务器');
             return false;
         }
 

package/checks/table.ts

@@ -6,8 +6,8 @@
 import path from 'node:path';
 import { Logger } from '../utils/logger.js';
 import { parseRule } from '../utils/index.js';
-import { __dirtables, getProjectDir } from '../system.js';
-import { scanAddons, getAddonDir } from '../utils/addonHelper.js';
+import { paths } from '../paths.js';
+import { scanAddons, getAddonDir } from '../utils/helper.js';
 
 /**
  * 表文件信息接口
@@ -15,8 +15,8 @@ import { scanAddons, getAddonDir } from '../utils/addonHelper.js';
 interface TableFileInfo {
     /** 表文件路径 */
     file: string;
-    /** 文件类型：core（核心）、project（项目）或 addon（组件） */
-    type: 'core' | 'project' | 'addon';
+    /** 文件类型：project（项目）或 addon（组件） */
+    type: 'project' | 'addon';
     /** 如果是 addon 类型，记录 addon 名称 */
     addonName?: string;
 }
@@ -29,13 +29,13 @@ const RESERVED_FIELDS = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'
 /**
  * 允许的字段类型
  */
-const FIELD_TYPES = ['string', 'number', 'text', 'array'] as const;
+const FIELD_TYPES = ['string', 'number', 'text', 'array_string', 'array_text'] as const;
 
 /**
  * 小驼峰命名正则
- * 可选：以下划线开头（用于特殊文件如 _common.json）
+ * 可选：以下划线开头（用于特殊文件，如通用字段定义）
  * 必须以小写字母开头，后续可包含小写/数字，或多个 [大写+小写/数字] 片段
- * 示例：userTable、testCustomers、common、_common
+ * 示例：userTable、testCustomers、common
  */
 const LOWER_CAMEL_CASE_REGEX = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
 
@@ -66,39 +66,17 @@ export default async function (): Promise<boolean> {
 
         // 收集所有表文件
         const allTableFiles: TableFileInfo[] = [];
-        const coreTableNames = new Set<string>(); // 存储内核表文件名
 
-        // 收集内核表字段定义文件
+        // 收集项目表字段定义文件
         for await (const file of tablesGlob.scan({
-            cwd: __dirtables,
+            cwd: paths.projectTableDir,
             absolute: true,
             onlyFiles: true
         })) {
-            const fileName = path.basename(file, '.json');
-            coreTableNames.add(fileName);
-            allTableFiles.push({ file, type: 'core' });
-        }
-
-        // 收集项目表字段定义文件，并检查是否与内核表同名
-        for await (const file of tablesGlob.scan({
-            cwd: getProjectDir('tables'),
-            absolute: true,
-            onlyFiles: true
-        })) {
-            const fileName = path.basename(file, '.json');
-
-            // 检查项目表是否与内核表同名
-            if (coreTableNames.has(fileName)) {
-                Logger.error(`项目表 ${fileName}.json 与内核表同名，项目表不能与内核表定义文件同名`);
-                invalidFiles++;
-                totalFiles++;
-                continue;
-            }
-
             allTableFiles.push({ file, type: 'project' });
         }
 
-        // 收集 addon 表字段定义文件，并检查是否与内核表同名
+        // 收集 addon 表字段定义文件
         const addons = scanAddons();
         for (const addonName of addons) {
             const addonTablesDir = getAddonDir(addonName, 'tables');
@@ -109,16 +87,6 @@ export default async function (): Promise<boolean> {
                     absolute: true,
                     onlyFiles: true
                 })) {
-                    const fileName = path.basename(file, '.json');
-
-                    // 检查 addon 表是否与内核表同名
-                    if (coreTableNames.has(fileName)) {
-                        Logger.error(`组件${addonName}表 ${fileName}.json 与内核表同名，addon 表不能与内核表定义文件同名`);
-                        invalidFiles++;
-                        totalFiles++;
-                        continue;
-                    }
-
                     allTableFiles.push({ file, type: 'addon', addonName });
                 }
             } catch (error) {
@@ -131,12 +99,12 @@ export default async function (): Promise<boolean> {
             totalFiles++;
             const fileName = path.basename(file);
             const fileBaseName = path.basename(file, '.json');
-            const fileType = type === 'core' ? '内核' : type === 'project' ? '项目' : `组件${addonName}`;
+            const fileType = type === 'project' ? '项目' : `组件${addonName}`;
 
             try {
                 // 1) 文件名小驼峰校验
                 if (!LOWER_CAMEL_CASE_REGEX.test(fileBaseName)) {
-                    Logger.error(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
+                    Logger.warn(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
                     // 命名不合规，记录错误并计为无效文件，继续下一个文件
                     invalidFiles++;
                     continue;
@@ -150,7 +118,7 @@ export default async function (): Promise<boolean> {
                 // 检查 table 中的每个验证规则
                 for (const [colKey, rule] of Object.entries(table)) {
                     if (typeof rule !== 'string') {
-                        Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为字符串`);
+                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为字符串`);
                         fileValid = false;
                         continue;
                     }
@@ -162,7 +130,7 @@ export default async function (): Promise<boolean> {
 
                         // 检查是否使用了保留字段
                         if (RESERVED_FIELDS.includes(colKey as any)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
+                            Logger.warn(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
                             fileValid = false;
                         }
 
@@ -171,7 +139,7 @@ export default async function (): Promise<boolean> {
                         try {
                             parsed = parseRule(rule);
                         } catch (error: any) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则解析失败：${error.message}`);
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则解析失败：${error.message}`);
                             fileValid = false;
                             continue;
                         }
@@ -180,37 +148,37 @@ export default async function (): Promise<boolean> {
 
                         // 第1个值：名称必须为中文、数字、字母、下划线、短横线、空格
                         if (!FIELD_NAME_REGEX.test(fieldName)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
                             fileValid = false;
                         }
 
-                        // 第2个值：字段类型必须为string,number,text,array之一
+                        // 第2个值：字段类型必须为string,number,text,array_string,array_text之一
                         if (!FIELD_TYPES.includes(fieldType as any)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
                             fileValid = false;
                         }
 
                         // 第3/4个值：需要是 null 或 数字
                         if (!(fieldMin === null || typeof fieldMin === 'number')) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
                             fileValid = false;
                         }
                         if (!(fieldMax === null || typeof fieldMax === 'number')) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
                             fileValid = false;
                         }
 
                         // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
                         if (fieldMin !== null && fieldMax !== null) {
                             if (fieldMin > fieldMax) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
+                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
                                 fileValid = false;
                             }
                         }
 
                         // 第6个值：是否创建索引必须为0或1
                         if (fieldIndex !== 0 && fieldIndex !== 1) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 索引标识 "${fieldIndex}" 格式错误，必须为0或1`);
+                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 索引标识 "${fieldIndex}" 格式错误，必须为0或1`);
                             fileValid = false;
                         }
 
@@ -221,28 +189,28 @@ export default async function (): Promise<boolean> {
                         if (fieldType === 'text') {
                             // text：min/max 必须为 null，默认值必须为 'null'
                             if (fieldMin !== null) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
+                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
                                 fileValid = false;
                             }
                             if (fieldMax !== null) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
+                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
                                 fileValid = false;
                             }
                             if (fieldDefault !== 'null') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
+                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
                                 fileValid = false;
                             }
                         } else if (fieldType === 'string' || fieldType === 'array') {
                             if (fieldMax === null || typeof fieldMax !== 'number') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
+                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
                                 fileValid = false;
                             } else if (fieldMax > MAX_VARCHAR_LENGTH) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
+                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
                                 fileValid = false;
                             }
                         } else if (fieldType === 'number') {
                             if (fieldDefault !== 'null' && typeof fieldDefault !== 'number') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或null，当前为 "${fieldDefault}"`);
+                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或null，当前为 "${fieldDefault}"`);
                                 fileValid = false;
                             }
                         }
@@ -264,17 +232,17 @@ export default async function (): Promise<boolean> {
         }
 
         // 输出统计信息
-        Logger.info(`\n表定义检查完成：`);
+        Logger.info(`表定义检查完成：`);
         Logger.info(`  总文件数: ${totalFiles}`);
         Logger.info(`  总规则数: ${totalRules}`);
         Logger.info(`  通过文件: ${validFiles}`);
         Logger.info(`  失败文件: ${invalidFiles}`);
 
         if (invalidFiles > 0) {
-            Logger.error(`\n表定义检查失败，请修复上述错误后重试`);
+            Logger.warn(`表定义检查失败，请修复上述错误后重试`);
             return false;
         } else {
-            Logger.info(`\n所有表定义检查通过 ✓`);
+            Logger.info(`所有表定义检查通过 ✓`);
             return true;
         }
     } catch (error: any) {

package/config/env.ts

@@ -26,8 +26,8 @@ export interface EnvConfig {
     PARAMS_CHECK: string;
 
     // ========== 日志配置 ==========
-    /** 日志等级：debug | info | warn | error */
-    LOG_LEVEL: string;
+    /** debug日志开关：0 | 1 */
+    LOG_DEBUG: number;
     /** 日志排除字段（逗号分隔） */
     LOG_EXCLUDE_FIELDS: string;
     /** 日志目录 */
@@ -158,7 +158,7 @@ export const Env: EnvConfig = {
     PARAMS_CHECK: getEnv('PARAMS_CHECK', 'true'),
 
     // ========== 日志配置 ==========
-    LOG_LEVEL: getEnv('LOG_LEVEL', 'info'),
+    LOG_DEBUG: getEnvNumber('LOG_DEBUG', 0),
     LOG_EXCLUDE_FIELDS: getEnv('LOG_EXCLUDE_FIELDS', 'password,token,secret'),
     LOG_DIR: getEnv('LOG_DIR', './logs'),
     LOG_TO_CONSOLE: getEnvNumber('LOG_TO_CONSOLE', 1),

package/config/fields.ts

@@ -0,0 +1,55 @@
+/**
+ * 通用字段定义
+ *
+ * 用于在 API 和表定义中复用常见字段规则
+ *
+ * 格式：`字段标签|数据类型|最小值|最大值|默认值|是否必填|正则表达式`
+ *
+ * 说明：
+ * - 字段标签：用于显示的中文名称
+ * - 数据类型：string、number、boolean、array_string、array_text 等
+ * - 最小值：string 类型表示最小长度，number 类型表示最小数值，array 类型表示最小元素个数
+ * - 最大值：string 类型表示最大长度，number 类型表示最大数值，array 类型表示最大元素个数
+ * - 默认值：字段的默认值，无默认值时填 null
+ * - 是否必填：0 表示非必填，1 表示必填
+ * - 正则表达式：用于验证字段值的正则表达式，无验证时填 null
+ *
+ * 类型说明：
+ * - array_string: 短数组，存储为 VARCHAR，建议设置 max 限制（如 0-100）
+ * - array_text: 长数组，存储为 MEDIUMTEXT，min/max 可设为 null 表示不限制
+ *
+ * 正则表达式别名：
+ * - 使用 @ 前缀可以引用内置正则表达式别名，例如：
+ *   - @number: 纯数字
+ *   - @alphanumeric: 字母+数字
+ *   - @email: 邮箱格式
+ *   - @phone: 中国手机号
+ *   - @chinese: 纯中文
+ * - 完整别名列表见 config/regexAliases.ts
+ *
+ * 示例：
+ * - '用户ID|array_text|null|null|null|0|@number' - 数字数组
+ * - '标签|array_string|0|50|null|0|@alphanumeric' - 字母数字数组
+ */
+
+export const Fields = {
+    _id: 'ID|number|1|null|null|1|null',
+    email: '邮箱|string|5|100|null|1|^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$',
+    phone: '手机号|string|11|11|null|1|^1[3-9]\\d{9}$',
+    page: '页码|number|1|9999|1|0|null',
+    limit: '每页数量|number|1|100|10|0|null',
+    title: '标题|string|1|200|null|0|null',
+    description: '描述|string|0|500|null|0|null',
+    keyword: '关键词|string|1|50|null|1|null',
+    keywords: '关键词列表|array_string|0|50|null|0|null',
+    enabled: '启用状态|number|0|1|1|0|^(0|1)$',
+    date: '日期|string|10|10|null|0|^\\d{4}-\\d{2}-\\d{2}$',
+    datetime: '日期时间|string|19|25|null|0|^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}',
+    filename: '文件名|string|1|255|null|0|null',
+    url: '网址|string|5|500|null|0|^https?://',
+    tag: '标签|array_string|0|10|null|0|null',
+    startTime: '开始时间|number|0|9999999999999|null|0|null',
+    endTime: '结束时间|number|0|9999999999999|null|0|null'
+} as const;
+
+export default Fields;