befly 2.3.2 → 3.0.0

package/utils/{xml.js → xml.ts}

@@ -1,39 +1,66 @@
 /**
- * XML 解析器
+ * XML 解析器 - TypeScript 版本
  * 将 XML 字符串解析为 JSON 对象
  */
-class Xml {
+
+/**
+ * XML 解析选项
+ */
+interface XmlParseOptions {
+    /** 是否忽略属性 */
+    ignoreAttributes?: boolean;
+    /** 属性前缀 */
+    attributePrefix?: string;
+    /** 文本内容的键名 */
+    textKey?: string;
+    /** 是否去除首尾空格 */
+    trimValues?: boolean;
+    /** 是否解析布尔值 */
+    parseBooleans?: boolean;
+    /** 是否解析数字 */
+    parseNumbers?: boolean;
+    /** 是否使用自定义解析器 */
+    customParser?: boolean;
+}
+
+/**
+ * 解析结果接口（内部使用）
+ */
+interface ParseResult {
+    value: Record<string, any>;
+    end: number;
+}
+
+/**
+ * XML 解析器类
+ */
+export class Xml {
+    private options: Required<XmlParseOptions>;
+
     /**
      * 构造函数
-     * @param {Object} options - 解析选项
+     * @param options - 解析选项
      */
-    constructor(options = {}) {
+    constructor(options: XmlParseOptions = {}) {
         // 默认配置
         this.options = {
-            // 基本配置
-            ignoreAttributes: false, // 是否忽略属性
-            attributePrefix: '@', // 属性前缀
-            textKey: '#text', // 文本内容的键名
-
-            // 格式化配置
-            trimValues: true, // 是否去除首尾空格
-            parseBooleans: true, // 是否解析布尔值
-            parseNumbers: true, // 是否解析数字
-
-            // 高级配置
-            customParser: true, // 是否使用自定义解析器
-
-            // 合并用户选项
+            ignoreAttributes: false,
+            attributePrefix: '@',
+            textKey: '#text',
+            trimValues: true,
+            parseBooleans: true,
+            parseNumbers: true,
+            customParser: true,
             ...options
         };
     }
 
     /**
      * 解析 XML 字符串为 JSON 对象
-     * @param {string} xmlData - XML 字符串
-     * @returns {Object} 解析后的 JSON 对象
+     * @param xmlData - XML 字符串
+     * @returns 解析后的 JSON 对象
      */
-    parse(xmlData) {
+    parse(xmlData: string): Record<string, any> {
         if (typeof xmlData !== 'string') {
             throw new Error('无效的 XML 数据');
         }
@@ -54,20 +81,22 @@ class Xml {
 
         // 自定义解析
         if (this.options.customParser) {
-            return this.#customParse(xmlData);
+            return this.customParse(xmlData);
         }
+
+        return {};
     }
 
     /**
      * 解析属性字符串
-     * @param {string} attributesStr - 属性字符串
-     * @param {Object} element - 元素对象
+     * @param attributesStr - 属性字符串
+     * @param element - 元素对象
      */
-    #parseAttributes(attributesStr, element) {
+    private parseAttributes(attributesStr: string, element: Record<string, any>): void {
         // 移除标签名，只保留属性部分
         const attrPart = attributesStr.replace(/^\w+\s*/, '');
         const attrRegex = /(\w+)=["']([^"']*)["']/g;
-        let match;
+        let match: RegExpExecArray | null;
 
         while ((match = attrRegex.exec(attrPart)) !== null) {
             const attrName = this.options.attributePrefix + match[1];
@@ -78,18 +107,18 @@ class Xml {
                 element[attrName] = attrValue;
             } else {
                 // 其他属性进行类型解析
-                element[attrName] = this.#parseValue(attrValue);
+                element[attrName] = this.parseValue(attrValue);
             }
         }
     }
 
     /**
      * 自定义解析方法
-     * @param {string} xmlData - XML 数据
-     * @returns {Object} 解析结果
+     * @param xmlData - XML 数据
+     * @returns 解析结果
      */
-    #customParse(xmlData) {
-        const result = this.#parseXmlElement(xmlData, 0).value;
+    private customParse(xmlData: string): Record<string, any> {
+        const result = this.parseXmlElement(xmlData, 0).value;
 
         // 如果结果只有一个根元素，返回该元素的内容
         const keys = Object.keys(result);
@@ -101,11 +130,11 @@ class Xml {
 
     /**
      * 解析 XML 元素
-     * @param {string} xml - XML 字符串
-     * @param {number} start - 开始位置
-     * @returns {Object} 包含解析结果和结束位置的对象
+     * @param xml - XML 字符串
+     * @param start - 开始位置
+     * @returns 包含解析结果和结束位置的对象
      */
-    #parseXmlElement(xml, start) {
+    private parseXmlElement(xml: string, start: number): ParseResult {
         const tagStart = xml.indexOf('<', start);
         if (tagStart === -1) {
             return { value: {}, end: xml.length };
@@ -117,13 +146,13 @@ class Xml {
         }
 
         const fullTag = xml.slice(tagStart + 1, tagEnd);
-        const element = {};
+        const element: Record<string, any> = {};
 
         // 自闭合标签
         if (fullTag.endsWith('/')) {
             const tagName = fullTag.slice(0, -1).split(/\s+/)[0];
             if (!this.options.ignoreAttributes && fullTag.includes(' ')) {
-                this.#parseAttributes(fullTag.slice(0, -1), element);
+                this.parseAttributes(fullTag.slice(0, -1), element);
             }
             return { value: { [tagName]: Object.keys(element).length > 0 ? element : '' }, end: tagEnd + 1 };
         }
@@ -134,7 +163,7 @@ class Xml {
             if (commentEnd === -1) {
                 throw new Error('格式错误：未找到注释结束符');
             }
-            return this.#parseXmlElement(xml, commentEnd + 3);
+            return this.parseXmlElement(xml, commentEnd + 3);
         }
 
         // CDATA
@@ -143,15 +172,14 @@ class Xml {
             if (cdataEnd === -1) {
                 throw new Error('格式错误：未找到 CDATA 结束符');
             }
-            const cdataContent = xml.slice(tagEnd + 1, cdataEnd);
-            return this.#parseXmlElement(xml, cdataEnd + 3);
+            return this.parseXmlElement(xml, cdataEnd + 3);
         }
 
         const tagName = fullTag.split(/\s+/)[0];
 
         // 解析属性
         if (!this.options.ignoreAttributes && fullTag.includes(' ')) {
-            this.#parseAttributes(fullTag, element);
+            this.parseAttributes(fullTag, element);
         }
 
         // 查找结束标签
@@ -171,7 +199,7 @@ class Xml {
 
         // 如果没有子标签，直接解析文本
         if (!content.includes('<')) {
-            const textValue = this.#parseValue(content);
+            const textValue = this.parseValue(content);
             if (Object.keys(element).length === 0) {
                 return { value: { [tagName]: textValue }, end: endTagStart + endTag.length };
             } else {
@@ -181,7 +209,7 @@ class Xml {
         } else {
             // 解析子元素和混合内容
             let pos = 0;
-            const texts = [];
+            const texts: string[] = [];
 
             while (pos < content.length) {
                 const nextTag = content.indexOf('<', pos);
@@ -200,12 +228,12 @@ class Xml {
                 }
 
                 // 解析子元素
-                const childResult = this.#parseXmlElement(content, nextTag);
+                const childResult = this.parseXmlElement(content, nextTag);
                 const childObj = childResult.value;
 
                 // 合并子元素到当前元素
                 for (const [key, value] of Object.entries(childObj)) {
-                    this.#addElement(element, key, value);
+                    this.addElement(element, key, value);
                 }
 
                 pos = childResult.end;
@@ -215,9 +243,9 @@ class Xml {
             if (texts.length > 0) {
                 const combinedText = texts.join(' ');
                 if (Object.keys(element).length === 0) {
-                    return { value: { [tagName]: this.#parseValue(combinedText) }, end: endTagStart + endTag.length };
+                    return { value: { [tagName]: this.parseValue(combinedText) }, end: endTagStart + endTag.length };
                 } else {
-                    element[this.options.textKey] = this.#parseValue(combinedText);
+                    element[this.options.textKey] = this.parseValue(combinedText);
                 }
             }
 
@@ -227,11 +255,11 @@ class Xml {
 
     /**
      * 添加元素到对象
-     * @param {Object} parent - 父对象
-     * @param {string} name - 元素名
-     * @param {any} value - 元素值
+     * @param parent - 父对象
+     * @param name - 元素名
+     * @param value - 元素值
      */
-    #addElement(parent, name, value) {
+    private addElement(parent: Record<string, any>, name: string, value: any): void {
         if (parent[name] === undefined) {
             parent[name] = value;
         } else if (Array.isArray(parent[name])) {
@@ -243,10 +271,10 @@ class Xml {
 
     /**
      * 解析值的类型
-     * @param {string} value - 原始值
-     * @returns {any} 解析后的值
+     * @param value - 原始值
+     * @returns 解析后的值
      */
-    #parseValue(value) {
+    private parseValue(value: string): string | number | boolean {
         if (!value || typeof value !== 'string') {
             return value;
         }
@@ -288,16 +316,16 @@ class Xml {
         }
 
         // 处理 XML 实体
-        return this.#decodeEntities(value);
+        return this.decodeEntities(value);
     }
 
     /**
      * 解码 XML 实体
-     * @param {string} value - 包含实体的字符串
-     * @returns {string} 解码后的字符串
+     * @param value - 包含实体的字符串
+     * @returns 解码后的字符串
      */
-    #decodeEntities(value) {
-        const entities = {
+    private decodeEntities(value: string): string {
+        const entities: Record<string, string> = {
             '&amp;': '&',
             '&lt;': '<',
             '&gt;': '>',
@@ -312,39 +340,39 @@ class Xml {
 
     /**
      * 静态方法：快速解析 XML
-     * @param {string} xmlData - XML 数据
-     * @param {Object} options - 解析选项
-     * @returns {Object} 解析后的 JSON 对象
+     * @param xmlData - XML 数据
+     * @param options - 解析选项
+     * @returns 解析后的 JSON 对象
      */
-    static parse(xmlData, options = {}) {
+    static parse(xmlData: string, options: XmlParseOptions = {}): Record<string, any> {
         const parser = new Xml(options);
         return parser.parse(xmlData);
     }
 
     /**
      * 静态方法：解析 XML 并保留属性
-     * @param {string} xmlData - XML 数据
-     * @returns {Object} 解析后的 JSON 对象
+     * @param xmlData - XML 数据
+     * @returns 解析后的 JSON 对象
      */
-    static parseWithAttributes(xmlData) {
+    static parseWithAttributes(xmlData: string): Record<string, any> {
         return Xml.parse(xmlData, { ignoreAttributes: false });
     }
 
     /**
      * 静态方法：解析 XML 并忽略属性
-     * @param {string} xmlData - XML 数据
-     * @returns {Object} 解析后的 JSON 对象
+     * @param xmlData - XML 数据
+     * @returns 解析后的 JSON 对象
      */
-    static parseIgnoreAttributes(xmlData) {
+    static parseIgnoreAttributes(xmlData: string): Record<string, any> {
         return Xml.parse(xmlData, { ignoreAttributes: true });
     }
 
     /**
      * 静态方法：验证 XML 格式
-     * @param {string} xmlData - XML 数据
-     * @returns {boolean} 是否有效
+     * @param xmlData - XML 数据
+     * @returns 是否有效
      */
-    static validate(xmlData) {
+    static validate(xmlData: string): boolean {
         try {
             Xml.parse(xmlData);
             return true;
@@ -353,5 +381,3 @@ class Xml {
         }
     }
 }
-
-export { Xml };

package/.npmrc

@@ -1,3 +0,0 @@
-# registry=https://registry.npmmirror.com
-registry=https://registry.npmjs.org
-link-workspace-packages=true

package/.prettierignore

@@ -1,2 +0,0 @@
-LICENSE
-LICENSE.md

package/.prettierrc

@@ -1,11 +0,0 @@
-{
-    "trailingComma": "none",
-    "tabWidth": 4,
-    "semi": true,
-    "singleQuote": true,
-    "printWidth": 1024,
-    "bracketSpacing": true,
-    "useTabs": false,
-    "arrowParens": "always",
-    "endOfLine": "lf"
-}

package/apis/health/info.js

@@ -1,49 +0,0 @@
-import { Env } from '../../config/env.js';
-import { Api } from '../../utils/api.js';
-import { RYes, RNo } from '../../utils/index.js';
-
-export default Api.POST(
-    //
-    '健康检查',
-    false,
-    {},
-    [],
-    async (befly, ctx) => {
-        try {
-            const info = {
-                status: 'ok',
-                timestamp: new Date().toISOString(),
-                uptime: process.uptime(),
-                memory: process.memoryUsage(),
-                runtime: 'Bun',
-                version: Bun.version,
-                platform: process.platform,
-                arch: process.arch
-            };
-            // 检查 Redis 连接状态
-            if (Env.REDIS_ENABLE === 1) {
-                if (befly.redis) {
-                    try {
-                        await befly.redis.ping();
-                        info.redis = '已连接';
-                    } catch (error) {
-                        info.redis = '未连接';
-                        info.redisError = error.message;
-                    }
-                } else {
-                    info.redis = '未开启';
-                }
-            } else {
-                info.redis = '禁用';
-            }
-            return RYes('健康检查成功', info);
-        } catch (error) {
-            befly.logger.error({
-                msg: '健康检查失败',
-                error: error.message,
-                stack: error.stack
-            });
-            return RNo('健康检查失败');
-        }
-    }
-);

package/apis/tool/tokenCheck.js

@@ -1,29 +0,0 @@
-import { Env } from '../../config/env.js';
-import { Api } from '../../utils/api.js';
-import { RYes, RNo } from '../../utils/index.js';
-import { Jwt } from '../../utils/jwt.js';
-
-export default Api.POST(
-    //
-    '令牌检测',
-    false,
-    {},
-    [],
-    async (befly, ctx) => {
-        try {
-            const token = ctx.headers?.authorization?.split(' ')[1] || '';
-            if (!token) {
-                return RNo('令牌不能为空');
-            }
-            const jwtData = await Jwt.verify(token);
-            return RYes('令牌有效');
-        } catch (error) {
-            befly.logger.error({
-                msg: '令牌检测失败',
-                error: error.message,
-                stack: error.stack
-            });
-            return RNo('令牌检测失败');
-        }
-    }
-);

package/checks/table.js

@@ -1,221 +0,0 @@
-import path from 'node:path';
-import { Logger } from '../utils/logger.js';
-import { parseFieldRule, validateFieldName, validateFieldType, validateMinMax, validateDefaultValue, validateIndex, validateRegex } from '../utils/index.js';
-import { __dirtables, getProjectDir } from '../system.js';
-
-// 所有校验函数均复用 utils/index.js 导出的实现
-
-export const checkTable = async () => {
-    try {
-        const tablesGlob = new Bun.Glob('*.json');
-
-        // 统计信息
-        let totalFiles = 0;
-        let totalRules = 0;
-        let validFiles = 0;
-        let invalidFiles = 0;
-
-        // 收集所有表文件
-        const allTableFiles = [];
-        const coreTableNames = new Set(); // 存储内核表文件名
-
-        // 收集内核表字段定义文件
-        for await (const file of tablesGlob.scan({
-            cwd: __dirtables,
-            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' });
-        }
-
-        // 保留字段列表
-        const reservedFields = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'];
-
-        // 合并进行验证逻辑
-        for (const { file, type } of allTableFiles) {
-            totalFiles++;
-            const fileName = path.basename(file);
-            const fileBaseName = path.basename(file, '.json');
-            const fileType = type === 'core' ? '内核' : '项目';
-
-            try {
-                // 1) 文件名小驼峰校验：必须以小写字母开头，后续可包含小写/数字，或多个 [大写+小写/数字] 片段
-                //    示例：userTable、testCustomers、common
-                const lowerCamelCaseRegex = /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
-                if (!lowerCamelCaseRegex.test(fileBaseName)) {
-                    Logger.error(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
-                    // 命名不合规，直接标记为无效文件
-                    throw new Error('文件命名不符合小驼峰规范');
-                }
-
-                // 读取并解析 JSON 文件
-                const table = await Bun.file(file).json();
-                let fileValid = true;
-                let fileRules = 0;
-
-                // 检查 table 中的每个验证规则
-                for (const [fieldName, rule] of Object.entries(table)) {
-                    fileRules++;
-                    totalRules++;
-
-                    // 检查是否使用了保留字段
-                    if (reservedFields.includes(fieldName)) {
-                        Logger.error(`${fileType}表 ${fileName} 文件包含保留字段 ${fieldName}，不能在表定义中使用以下字段: ${reservedFields.join(', ')}`);
-                        fileValid = false;
-                        continue;
-                    }
-
-                    // 验证规则格式
-                    try {
-                        const ruleParts = parseFieldRule(rule);
-
-                        if (ruleParts.length !== 7) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${fieldName} 验证规则错误，应包含 7 个部分，但包含 ${ruleParts.length} 个部分`);
-                            fileValid = false;
-                            continue;
-                        }
-
-                        const [name, type, minStr, maxStr, defaultValue, isIndexStr, regexConstraint] = ruleParts;
-
-                        // 使用新的验证函数进行严格验证
-                        // 第1个值：名称必须为中文、数字、字母
-                        if (!validateFieldName(name)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 名称 "${name}" 格式错误，必须为中文、数字、字母`);
-                            fileValid = false;
-                            continue;
-                        }
-
-                        // 第2个值：字段类型必须为string,number,text,array之一
-                        if (!validateFieldType(type)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 类型 "${type}" 格式错误，必须为string、number、text、array之一`);
-                            fileValid = false;
-                            continue;
-                        }
-
-                        // 第3个值：最小值必须为null或数字
-                        if (!validateMinMax(minStr)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最小值 "${minStr}" 格式错误，必须为null或数字`);
-                            fileValid = false;
-                            continue;
-                        }
-
-                        // 第4个值与类型联动校验
-                        if (type === 'text') {
-                            // text 类型：不允许设置最小/最大长度与默认值（均需为 null）
-                            if (minStr !== 'null') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 的 text 类型最小值必须为 null，当前为 "${minStr}"`);
-                                fileValid = false;
-                                continue;
-                            }
-                            if (maxStr !== 'null') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 的 text 类型最大长度必须为 null，当前为 "${maxStr}"`);
-                                fileValid = false;
-                                continue;
-                            }
-                        } else if (type === 'string') {
-                            // string：最大长度必为具体数字，且 1..65535
-                            if (maxStr === 'null' || !validateMinMax(maxStr)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 "${maxStr}" 格式错误，string 类型必须为具体数字`);
-                                fileValid = false;
-                                continue;
-                            }
-                            const maxVal = parseInt(maxStr, 10);
-                            if (!(maxVal > 0 && maxVal <= 65535)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 ${maxStr} 越界，string 类型长度必须在 1..65535 范围内`);
-                                fileValid = false;
-                                continue;
-                            }
-                        } else if (type === 'array') {
-                            // array：最大长度必为数字（用于JSON字符串长度限制）
-                            if (maxStr === 'null' || !validateMinMax(maxStr)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大长度 "${maxStr}" 格式错误，array 类型必须为具体数字`);
-                                fileValid = false;
-                                continue;
-                            }
-                        } else {
-                            // number 等其他：允许 null 或数字
-                            if (!validateMinMax(maxStr)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 最大值 "${maxStr}" 格式错误，必须为null或数字`);
-                                fileValid = false;
-                                continue;
-                            }
-                        }
-
-                        // 第5个值：默认值校验
-                        if (type === 'text') {
-                            // text 不允许默认值
-                            if (defaultValue !== 'null') {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 为 text 类型，默认值必须为 null，当前为 "${defaultValue}"`);
-                                fileValid = false;
-                                continue;
-                            }
-                        } else {
-                            if (!validateDefaultValue(defaultValue)) {
-                                Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 默认值 "${defaultValue}" 格式错误，必须为null、字符串或数字`);
-                                fileValid = false;
-                                continue;
-                            }
-                        }
-
-                        // 第6个值：是否创建索引必须为0或1
-                        if (!validateIndex(isIndexStr)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 索引标识 "${isIndexStr}" 格式错误，必须为0或1`);
-                            fileValid = false;
-                            continue;
-                        }
-
-                        // 第7个值：必须为null或正则表达式
-                        if (!validateRegex(regexConstraint)) {
-                            Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 正则约束 "${regexConstraint}" 格式错误，必须为null或有效的正则表达式`);
-                            fileValid = false;
-                            continue;
-                        }
-                    } catch (error) {
-                        Logger.error(`${fileType}表 ${fileName} 文件 ${fieldName} 验证规则解析失败: ${error.message}`);
-                        fileValid = false;
-                        continue;
-                    }
-                }
-
-                if (fileValid) {
-                    validFiles++;
-                } else {
-                    invalidFiles++;
-                }
-            } catch (error) {
-                Logger.error(`${fileType}表 ${fileName} 解析失败: ${error.message}`);
-                invalidFiles++;
-            }
-        }
-
-        if (invalidFiles > 0) {
-            return false;
-        } else {
-            return true;
-        }
-    } catch (error) {
-        Logger.error(`Tables 检查过程中出错:`, error);
-        return false;
-    }
-};