befly 2.3.3 → 3.0.0

package/checks/{table.js → table.ts}

@@ -1,11 +1,60 @@
+/**
+ * 表规则检查器 - TypeScript 版本
+ * 验证表定义文件的格式和规则
+ */
+
 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';
+
+/**
+ * 表文件信息接口
+ */
+interface TableFileInfo {
+    /** 表文件路径 */
+    file: string;
+    /** 文件类型：core（核心）、project（项目）或 addon（组件） */
+    type: 'core' | 'project' | 'addon';
+    /** 如果是 addon 类型，记录 addon 名称 */
+    addonName?: string;
+}
+
+/**
+ * 保留字段列表
+ */
+const RESERVED_FIELDS = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'] as const;
+
+/**
+ * 允许的字段类型
+ */
+const FIELD_TYPES = ['string', 'number', 'text', 'array'] as const;
 
-// 所有校验函数均复用 utils/index.js 导出的实现
+/**
+ * 小驼峰命名正则
+ * 可选：以下划线开头（用于特殊文件如 _common.json）
+ * 必须以小写字母开头，后续可包含小写/数字，或多个 [大写+小写/数字] 片段
+ * 示例：userTable、testCustomers、common、_common
+ */
+const LOWER_CAMEL_CASE_REGEX = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
 
-export const checkTable = async () => {
+/**
+ * 字段名称正则
+ * 必须为中文、数字、字母、下划线、短横线、空格
+ */
+const FIELD_NAME_REGEX = /^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/;
+
+/**
+ * VARCHAR 最大长度限制
+ */
+const MAX_VARCHAR_LENGTH = 65535;
+
+/**
+ * 检查表定义文件
+ * @returns 检查是否通过
+ */
+export default async function (): Promise<boolean> {
     try {
         const tablesGlob = new Bun.Glob('*.json');
 
@@ -16,8 +65,8 @@ export const checkTable = async () => {
         let invalidFiles = 0;
 
         // 收集所有表文件
-        const allTableFiles = [];
-        const coreTableNames = new Set(); // 存储内核表文件名
+        const allTableFiles: TableFileInfo[] = [];
+        const coreTableNames = new Set<string>(); // 存储内核表文件名
 
         // 收集内核表字段定义文件
         for await (const file of tablesGlob.scan({
@@ -49,23 +98,46 @@ export const checkTable = async () => {
             allTableFiles.push({ file, type: 'project' });
         }
 
-        // 保留字段列表
-        const reservedFields = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'];
+        // 收集 addon 表字段定义文件，并检查是否与内核表同名
+        const addons = scanAddons();
+        for (const addonName of addons) {
+            const addonTablesDir = getAddonDir(addonName, 'tables');
+
+            try {
+                for await (const file of tablesGlob.scan({
+                    cwd: addonTablesDir,
+                    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) {
+                // addon 的 tables 目录可能不存在，跳过
+            }
+        }
 
         // 合并进行验证逻辑
-        for (const { file, type } of allTableFiles) {
+        for (const { file, type, addonName } of allTableFiles) {
             totalFiles++;
             const fileName = path.basename(file);
             const fileBaseName = path.basename(file, '.json');
-            const fileType = type === 'core' ? '内核' : '项目';
+            const fileType = type === 'core' ? '内核' : type === 'project' ? '项目' : `组件${addonName}`;
 
             try {
-                // 1) 文件名小驼峰校验：必须以小写字母开头，后续可包含小写/数字，或多个 [大写+小写/数字] 片段
-                //    示例：userTable、testCustomers、common
-                const lowerCamelCaseRegex = /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
-                if (!lowerCamelCaseRegex.test(fileBaseName)) {
+                // 1) 文件名小驼峰校验
+                if (!LOWER_CAMEL_CASE_REGEX.test(fileBaseName)) {
                     Logger.error(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
-                    // 命名不合规，按保留字段处理模式：记录错误并计为无效文件，继续下一个文件
+                    // 命名不合规，记录错误并计为无效文件，继续下一个文件
                     invalidFiles++;
                     continue;
                 }
@@ -77,83 +149,82 @@ export const checkTable = async () => {
 
                 // 检查 table 中的每个验证规则
                 for (const [colKey, rule] of Object.entries(table)) {
+                    if (typeof rule !== 'string') {
+                        Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为字符串`);
+                        fileValid = false;
+                        continue;
+                    }
+
                     // 验证规则格式
                     try {
                         fileRules++;
                         totalRules++;
 
                         // 检查是否使用了保留字段
-                        if (reservedFields.includes(colKey)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，不能在表定义中使用以下字段: ${reservedFields.join(', ')}`);
+                        if (RESERVED_FIELDS.includes(colKey as any)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
                             fileValid = false;
                         }
 
-                        const allParts = rule.split('⚡');
-
-                        // 必须包含7个部分：显示名⚡类型⚡最小值⚡最大值⚡默认值⚡是否索引⚡正则约束
-                        if (allParts.length !== 7) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则格式错误，必须包含7个部分，当前包含${allParts.length}个部分`);
+                        // 使用 parseRule 解析字段规则
+                        let parsed;
+                        try {
+                            parsed = parseRule(rule);
+                        } catch (error: any) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则解析失败：${error.message}`);
                             fileValid = false;
+                            continue;
                         }
 
-                        const [fieldName, fieldType, fieldMin, fieldMax, fieldDefault, fieldIndex, fieldRegx] = allParts;
+                        const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault, index: fieldIndex, regex: fieldRegx } = parsed;
 
-                        // 第1个值：名称必须为中文、数字、字母
-                        if (!/^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/.test(fieldName)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，必须为中文、数字、字母、下划线、短横线`);
+                        // 第1个值：名称必须为中文、数字、字母、下划线、短横线、空格
+                        if (!FIELD_NAME_REGEX.test(fieldName)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
                             fileValid = false;
                         }
 
                         // 第2个值：字段类型必须为string,number,text,array之一
-                        if (!['string', 'number', 'text', 'array'].includes(fieldType)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，必须为string、number、text、array之一`);
+                        if (!FIELD_TYPES.includes(fieldType as any)) {
+                            Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
                             fileValid = false;
                         }
 
-                        // 第3/4个值：需要是 null 或 数字（并包含最小值<=最大值的约束）
-                        if (!(fieldMin === 'null' || !Number.isNaN(Number(fieldMin)))) {
+                        // 第3/4个值：需要是 null 或 数字
+                        if (!(fieldMin === null || typeof fieldMin === 'number')) {
                             Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
                             fileValid = false;
                         }
-                        if (!(fieldMax === 'null' || !Number.isNaN(Number(fieldMax)))) {
+                        if (!(fieldMax === null || typeof fieldMax === 'number')) {
                             Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
                             fileValid = false;
                         }
 
                         // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
-                        if (fieldMin !== 'null' && fieldMax !== 'null') {
-                            if (Number(fieldMin) > Number(fieldMax)) {
+                        if (fieldMin !== null && fieldMax !== null) {
+                            if (fieldMin > fieldMax) {
                                 Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
                                 fileValid = false;
                             }
                         }
 
                         // 第6个值：是否创建索引必须为0或1
-                        if (fieldIndex !== '0' && fieldIndex !== '1') {
+                        if (fieldIndex !== 0 && fieldIndex !== 1) {
                             Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 索引标识 "${fieldIndex}" 格式错误，必须为0或1`);
                             fileValid = false;
                         }
 
-                        // 第7个值：必须为null或正则表达式
-                        if (fieldRegx !== 'null') {
-                            try {
-                                // 仅尝试构造以校验有效性
-                                // eslint-disable-next-line no-new
-                                new RegExp(fieldRegx);
-                            } catch (_) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 正则约束 "${fieldRegx}" 格式错误，必须为null或有效的正则表达式`);
-                                fileValid = false;
-                            }
-                        }
+                        // 第7个值：必须为null或正则表达式（parseRule已经验证过了）
+                        // parseRule 已经将正则字符串转换为 RegExp 或 null，这里不需要再验证
 
-                        // 第4个值与类型联动校验 + 默认值规则（精简实现）
+                        // 第4个值与类型联动校验 + 默认值规则
                         if (fieldType === 'text') {
                             // text：min/max 必须为 null，默认值必须为 'null'
-                            if (fieldMin !== 'null') {
+                            if (fieldMin !== null) {
                                 Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
                                 fileValid = false;
                             }
-                            if (fieldMax !== 'null') {
+                            if (fieldMax !== null) {
                                 Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
                                 fileValid = false;
                             }
@@ -162,45 +233,52 @@ export const checkTable = async () => {
                                 fileValid = false;
                             }
                         } else if (fieldType === 'string' || fieldType === 'array') {
-                            if (Number.isNaN(Number(fieldMax))) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 string,array 类型，最大长度必须为数字，当前为 "${fieldMax}"`);
+                            if (fieldMax === null || typeof fieldMax !== 'number') {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
                                 fileValid = false;
-                            }
-                            const maxVal = parseInt(fieldMax, 10);
-                            if (maxVal > 65535) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，string,array 类型长度必须在 1..65535 范围内`);
+                            } else if (fieldMax > MAX_VARCHAR_LENGTH) {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
                                 fileValid = false;
                             }
                         } else if (fieldType === 'number') {
-                            if (Number.isNaN(Number(fieldDefault))) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，默认值必须为数字，当前为 "${fieldDefault}"`);
+                            if (fieldDefault !== 'null' && typeof fieldDefault !== 'number') {
+                                Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或null，当前为 "${fieldDefault}"`);
                                 fileValid = false;
                             }
                         }
-                    } catch (error) {
-                        Logger.error(`${fileType}表 ${fileName} 文件 ${colKey} 验证规则解析失败: ${error.message}`);
-                        fileValid = false;
+                    } catch (error: any) {
+                        // 单个字段规则解析失败已在上面处理
                     }
                 }
 
                 if (fileValid) {
                     validFiles++;
+                    Logger.info(`${fileType}表 ${fileName} 验证通过（${fileRules} 个字段）`);
                 } else {
                     invalidFiles++;
                 }
-            } catch (error) {
+            } catch (error: any) {
                 Logger.error(`${fileType}表 ${fileName} 解析失败: ${error.message}`);
                 invalidFiles++;
             }
         }
 
+        // 输出统计信息
+        Logger.info(`\n表定义检查完成：`);
+        Logger.info(`  总文件数: ${totalFiles}`);
+        Logger.info(`  总规则数: ${totalRules}`);
+        Logger.info(`  通过文件: ${validFiles}`);
+        Logger.info(`  失败文件: ${invalidFiles}`);
+
         if (invalidFiles > 0) {
+            Logger.error(`\n表定义检查失败，请修复上述错误后重试`);
             return false;
         } else {
+            Logger.info(`\n所有表定义检查通过 ✓`);
             return true;
         }
-    } catch (error) {
-        Logger.error(`Tables 检查过程中出错:`, error);
+    } catch (error: any) {
+        Logger.error('数据表定义检查过程中出错:', error);
         return false;
     }
-};
+}

package/config/env.ts

@@ -0,0 +1,218 @@
+/**
+ * 环境变量配置 - TypeScript 版本
+ * 类型化所有环境变量
+ */
+
+/**
+ * 环境变量配置接口
+ */
+export interface EnvConfig {
+    // ========== 项目配置 ==========
+    /** 项目模式：development | production | test */
+    NODE_ENV: string;
+    /** 应用名称 */
+    APP_NAME: string;
+    /** MD5 加密盐 */
+    MD5_SALT: string;
+    /** 监听端口 */
+    APP_PORT: number;
+    /** 监听主机 */
+    APP_HOST: string;
+    /** 超级管理员密码 */
+    DEV_PASSWORD: string;
+    /** 请求体大小限制（字节） */
+    BODY_LIMIT: number;
+    /** 是否进行参数验证 */
+    PARAMS_CHECK: string;
+
+    // ========== 日志配置 ==========
+    /** 日志等级：debug | info | warn | error */
+    LOG_LEVEL: string;
+    /** 日志排除字段（逗号分隔） */
+    LOG_EXCLUDE_FIELDS: string;
+    /** 日志目录 */
+    LOG_DIR: string;
+    /** 是否输出到控制台：0 | 1 */
+    LOG_TO_CONSOLE: number;
+    /** 日志文件最大大小（字节） */
+    LOG_MAX_SIZE: number;
+
+    // ========== 时区配置 ==========
+    /** 时区：Asia/Shanghai */
+    TZ: string;
+
+    // ========== 数据库配置 ==========
+    /** 是否启用数据库：0 | 1 */
+    DB_ENABLE: number;
+    /** 数据库类型：sqlite | mysql | postgresql */
+    DB_TYPE: string;
+    /** 数据库主机 */
+    DB_HOST: string;
+    /** 数据库端口 */
+    DB_PORT: number;
+    /** 数据库用户名 */
+    DB_USER: string;
+    /** 数据库密码 */
+    DB_PASS: string;
+    /** 数据库名称 */
+    DB_NAME: string;
+    /** 是否启用调试：0 | 1 */
+    DB_DEBUG: number;
+    /** 连接池最大连接数 */
+    DB_POOL_MAX: number;
+
+    // ========== Redis 配置 ==========
+    /** 是否启用 Redis：0 | 1 */
+    REDIS_ENABLE: number;
+    /** Redis 主机 */
+    REDIS_HOST: string;
+    /** Redis 端口 */
+    REDIS_PORT: number;
+    /** Redis 用户名 */
+    REDIS_USERNAME: string;
+    /** Redis 密码 */
+    REDIS_PASSWORD: string;
+    /** Redis 数据库索引 */
+    REDIS_DB: number;
+    /** Redis 键前缀 */
+    REDIS_KEY_PREFIX: string;
+
+    // ========== JWT 配置 ==========
+    /** JWT 密钥 */
+    JWT_SECRET: string;
+    /** JWT 过期时间：7d | 30d | 1h */
+    JWT_EXPIRES_IN: string;
+    /** JWT 算法：HS256 | HS384 | HS512 */
+    JWT_ALGORITHM: string;
+
+    // ========== CORS 配置 ==========
+    /** 允许的来源 */
+    ALLOWED_ORIGIN: string;
+    /** 允许的方法 */
+    ALLOWED_METHODS: string;
+    /** 允许的头部 */
+    ALLOWED_HEADERS: string;
+    /** 暴露的头部 */
+    EXPOSE_HEADERS: string;
+    /** 预检请求缓存时间（秒） */
+    MAX_AGE: number;
+    /** 是否允许凭证 */
+    ALLOW_CREDENTIALS: string;
+
+    // ========== 邮件配置 ==========
+    /** 邮件服务器主机 */
+    MAIL_HOST: string;
+    /** 邮件服务器端口 */
+    MAIL_PORT: number;
+    /** 是否使用连接池 */
+    MAIL_POOL: string;
+    /** 是否使用 SSL */
+    MAIL_SECURE: string;
+    /** 邮件用户名 */
+    MAIL_USER: string;
+    /** 邮件密码 */
+    MAIL_PASS: string;
+    /** 发件人名称 */
+    MAIL_SENDER: string;
+    /** 发件人地址 */
+    MAIL_ADDRESS: string;
+
+    // ========== 同步脚本配置 ==========
+    /** 是否合并 ALTER 语句 */
+    SYNC_MERGE_ALTER: string;
+    /** 是否同步在线索引 */
+    SYNC_ONLINE_INDEX: string;
+    /** 是否禁止字段缩小 */
+    SYNC_DISALLOW_SHRINK: string;
+    /** 是否允许类型变更 */
+    SYNC_ALLOW_TYPE_CHANGE: string;
+}
+
+/**
+ * 获取环境变量值（带默认值）
+ */
+const getEnv = (key: string, defaultValue: string = ''): string => {
+    return process.env[key] || defaultValue;
+};
+
+/**
+ * 获取数字类型环境变量
+ */
+const getEnvNumber = (key: string, defaultValue: number = 0): number => {
+    const value = process.env[key];
+    return value ? Number(value) : defaultValue;
+};
+
+/**
+ * 环境变量配置对象
+ */
+export const Env: EnvConfig = {
+    // ========== 项目配置 ==========
+    NODE_ENV: getEnv('NODE_ENV', 'development'),
+    APP_NAME: getEnv('APP_NAME', 'befly'),
+    MD5_SALT: getEnv('MD5_SALT', 'befly'),
+    APP_PORT: getEnvNumber('APP_PORT', 3000),
+    APP_HOST: getEnv('APP_HOST', '0.0.0.0'),
+    DEV_PASSWORD: getEnv('DEV_PASSWORD', ''),
+    BODY_LIMIT: getEnvNumber('BODY_LIMIT', 10485760), // 10MB
+    PARAMS_CHECK: getEnv('PARAMS_CHECK', 'true'),
+
+    // ========== 日志配置 ==========
+    LOG_LEVEL: getEnv('LOG_LEVEL', 'info'),
+    LOG_EXCLUDE_FIELDS: getEnv('LOG_EXCLUDE_FIELDS', 'password,token,secret'),
+    LOG_DIR: getEnv('LOG_DIR', './logs'),
+    LOG_TO_CONSOLE: getEnvNumber('LOG_TO_CONSOLE', 1),
+    LOG_MAX_SIZE: getEnvNumber('LOG_MAX_SIZE', 10485760), // 10MB
+
+    // ========== 时区配置 ==========
+    TZ: getEnv('TZ', 'Asia/Shanghai'),
+
+    // ========== 数据库配置 ==========
+    DB_ENABLE: getEnvNumber('DB_ENABLE', 1),
+    DB_TYPE: getEnv('DB_TYPE', 'mysql'),
+    DB_HOST: getEnv('DB_HOST', 'localhost'),
+    DB_PORT: getEnvNumber('DB_PORT', 3306),
+    DB_USER: getEnv('DB_USER', 'root'),
+    DB_PASS: getEnv('DB_PASS', ''),
+    DB_NAME: getEnv('DB_NAME', 'befly'),
+    DB_DEBUG: getEnvNumber('DB_DEBUG', 0),
+    DB_POOL_MAX: getEnvNumber('DB_POOL_MAX', 10),
+
+    // ========== Redis 配置 ==========
+    REDIS_ENABLE: getEnvNumber('REDIS_ENABLE', 1),
+    REDIS_HOST: getEnv('REDIS_HOST', 'localhost'),
+    REDIS_PORT: getEnvNumber('REDIS_PORT', 6379),
+    REDIS_USERNAME: getEnv('REDIS_USERNAME', ''),
+    REDIS_PASSWORD: getEnv('REDIS_PASSWORD', ''),
+    REDIS_DB: getEnvNumber('REDIS_DB', 0),
+    REDIS_KEY_PREFIX: getEnv('REDIS_KEY_PREFIX', 'befly'),
+
+    // ========== JWT 配置 ==========
+    JWT_SECRET: getEnv('JWT_SECRET', 'befly-secret'),
+    JWT_EXPIRES_IN: getEnv('JWT_EXPIRES_IN', '7d'),
+    JWT_ALGORITHM: getEnv('JWT_ALGORITHM', 'HS256'),
+
+    // ========== CORS 配置 ==========
+    ALLOWED_ORIGIN: getEnv('ALLOWED_ORIGIN', '*'),
+    ALLOWED_METHODS: getEnv('ALLOWED_METHODS', 'GET, POST, PUT, DELETE, OPTIONS'),
+    ALLOWED_HEADERS: getEnv('ALLOWED_HEADERS', 'Content-Type, Authorization, authorization, token'),
+    EXPOSE_HEADERS: getEnv('EXPOSE_HEADERS', 'Content-Range, X-Content-Range, Authorization, authorization, token'),
+    MAX_AGE: getEnvNumber('MAX_AGE', 86400),
+    ALLOW_CREDENTIALS: getEnv('ALLOW_CREDENTIALS', 'true'),
+
+    // ========== 邮件配置 ==========
+    MAIL_HOST: getEnv('MAIL_HOST', ''),
+    MAIL_PORT: getEnvNumber('MAIL_PORT', 587),
+    MAIL_POOL: getEnv('MAIL_POOL', 'true'),
+    MAIL_SECURE: getEnv('MAIL_SECURE', 'false'),
+    MAIL_USER: getEnv('MAIL_USER', ''),
+    MAIL_PASS: getEnv('MAIL_PASS', ''),
+    MAIL_SENDER: getEnv('MAIL_SENDER', ''),
+    MAIL_ADDRESS: getEnv('MAIL_ADDRESS', ''),
+
+    // ========== 同步脚本配置 ==========
+    SYNC_MERGE_ALTER: getEnv('SYNC_MERGE_ALTER', 'false'),
+    SYNC_ONLINE_INDEX: getEnv('SYNC_ONLINE_INDEX', 'false'),
+    SYNC_DISALLOW_SHRINK: getEnv('SYNC_DISALLOW_SHRINK', 'true'),
+    SYNC_ALLOW_TYPE_CHANGE: getEnv('SYNC_ALLOW_TYPE_CHANGE', 'false')
+};

package/config/reserved.ts

@@ -0,0 +1,96 @@
+/**
+ * 核心保留名称配置
+ * 定义框架保留的资源名称，防止用户和 addon 使用
+ */
+
+/**
+ * 保留名称配置
+ */
+export const RESERVED_NAMES = {
+    /**
+     * 核心表前缀（禁止用户使用）
+     */
+    tablePrefix: ['sys_'],
+
+    /**
+     * 核心 API 路由前缀（禁止用户使用）
+     */
+    apiRoutes: ['/api/health', '/api/tool'],
+
+    /**
+     * 核心插件名（禁止用户使用）
+     */
+    plugins: ['db', 'logger', 'redis', 'tool'],
+
+    /**
+     * 禁止用作 addon 名称
+     */
+    addonNames: ['core', 'system', 'admin', 'sys', 'befly', 'app', 'api', 'config', 'utils', 'types']
+} as const;
+
+/**
+ * 检测表名是否使用了保留前缀
+ */
+export function isReservedTableName(tableName: string): boolean {
+    return RESERVED_NAMES.tablePrefix.some((prefix) => tableName.startsWith(prefix));
+}
+
+/**
+ * 检测 API 路由是否使用了保留路径
+ */
+export function isReservedRoute(route: string): boolean {
+    // 移除方法前缀（如 POST/GET）
+    const path = route.replace(/^(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)\//i, '/');
+    return RESERVED_NAMES.apiRoutes.some((reserved) => path.startsWith(reserved));
+}
+
+/**
+ * 检测插件名是否使用了保留名称
+ */
+export function isReservedPluginName(pluginName: string): boolean {
+    // 检测核心插件名
+    if (RESERVED_NAMES.plugins.includes(pluginName)) {
+        return true;
+    }
+    // 检测是否使用点号命名空间但前缀是保留名称
+    if (pluginName.includes('.')) {
+        const prefix = pluginName.split('.')[0];
+        return RESERVED_NAMES.plugins.includes(prefix);
+    }
+    return false;
+}
+
+/**
+ * 检测 addon 名称是否使用了保留名称
+ */
+export function isReservedAddonName(addonName: string): boolean {
+    return RESERVED_NAMES.addonNames.includes(addonName.toLowerCase());
+}
+
+/**
+ * 获取保留前缀列表（用于错误提示）
+ */
+export function getReservedTablePrefixes(): string[] {
+    return [...RESERVED_NAMES.tablePrefix];
+}
+
+/**
+ * 获取保留路由列表（用于错误提示）
+ */
+export function getReservedRoutes(): string[] {
+    return [...RESERVED_NAMES.apiRoutes];
+}
+
+/**
+ * 获取保留插件名列表（用于错误提示）
+ */
+export function getReservedPlugins(): string[] {
+    return [...RESERVED_NAMES.plugins];
+}
+
+/**
+ * 获取保留 addon 名称列表（用于错误提示）
+ */
+export function getReservedAddonNames(): string[] {
+    return [...RESERVED_NAMES.addonNames];
+}