befly 2.3.1 → 2.3.3

package/scripts/syncDev.js

@@ -0,0 +1,96 @@
+/**
+ * 同步开发管理员账号脚本
+ * - 账号: dev
+ * - 密码: Crypto2.hmacMd5(Crypto2.md5(Env.DEV_PASSWORD), Env.MD5_SALT)
+ * - 行为: 若存在则更新密码与 updated_at；不存在则插入新记录
+ */
+
+import { Env } from '../config/env.js';
+import { Logger } from '../utils/logger.js';
+import { createSqlClient } from '../utils/index.js';
+import { Crypto2 } from '../utils/crypto.js';
+
+// 命令行参数（保持与 syncDb.js 一致的 plan 行为）
+const ARGV = Array.isArray(process.argv) ? process.argv : [];
+const CLI = { DRY_RUN: ARGV.includes('--plan') };
+
+// 执行器封装
+const exec = async (client, query, params = []) => {
+    if (params && params.length > 0) return await client.unsafe(query, params);
+    return await client.unsafe(query);
+};
+
+/**
+ * 同步开发管理员账号
+ * @param {import('bun').SQL | null} client 可选，复用已有 SQL 客户端；不传则内部创建与关闭
+ */
+export async function SyncDev(client = null) {
+    let ownClient = false;
+    try {
+        if (CLI.DRY_RUN) {
+            Logger.info('[计划] 同步完成后将初始化/更新 admin.dev 账号（plan 模式不执行）');
+            return true;
+        }
+
+        if (!Env.DEV_PASSWORD || !Env.MD5_SALT) {
+            Logger.warn('跳过开发管理员初始化：缺少 DEV_PASSWORD 或 MD5_SALT 配置');
+            return false;
+        }
+
+        if (!client) {
+            client = await createSqlClient({ max: 1 });
+            ownClient = true;
+        }
+
+        // 检查 admin 表是否存在
+        const [exist] = await exec(client, 'SELECT COUNT(*) AS cnt FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? LIMIT 1', [Env.DB_NAME || '', 'admin']);
+        if (!exist || Number(exist.cnt) === 0) {
+            Logger.warn('跳过开发管理员初始化：未检测到 admin 表');
+            return false;
+        }
+
+        const nowTs = Date.now();
+        const hashed = Crypto2.hmacMd5(Crypto2.md5(Env.DEV_PASSWORD), Env.MD5_SALT);
+
+        // 更新存在的 dev 账号
+        const updateRes = await exec(client, 'UPDATE `admin` SET `password` = ?, `updated_at` = ? WHERE `account` = ? LIMIT 1', [hashed, nowTs, 'dev']);
+        const affected = updateRes?.affectedRows ?? updateRes?.rowsAffected ?? 0;
+
+        if (!affected || affected === 0) {
+            // 插入新账号
+            const id = nowTs;
+            await exec(client, 'INSERT INTO `admin` (`id`, `created_at`, `updated_at`, `deleted_at`, `state`, `account`, `password`) VALUES (?, ?, ?, 0, 0, ?, ?)', [id, nowTs, nowTs, 'dev', hashed]);
+            Logger.info('开发管理员已初始化：account=dev');
+        } else {
+            Logger.info('开发管理员已更新密码并刷新更新时间：account=dev');
+        }
+
+        return true;
+    } catch (e) {
+        Logger.warn(`开发管理员初始化步骤出错：${e.message}`);
+        return false;
+    } finally {
+        if (ownClient && client) {
+            try {
+                await client.close();
+            } catch (e) {
+                Logger.warn('关闭数据库连接时出错:', e.message);
+            }
+        }
+    }
+}
+
+// 允许直接运行该脚本
+if (import.meta.url === `file://${process.argv[1]}`) {
+    SyncDev()
+        .then((ok) => {
+            if (CLI.DRY_RUN) {
+                process.exit(0);
+            }
+            process.exit(ok ? 0 : 1);
+        })
+        .catch((err) => {
+            console.error('❌ 开发管理员同步失败:', err);
+            process.exit(1);
+        });
+}

package/tables/common.json

@@ -1,16 +1,16 @@
 {
-    "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}$",
+    "email": "邮箱⚡string⚡5⚡100⚡''⚡1⚡^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
+    "phone": "手机号⚡string⚡11⚡11⚡''⚡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",
+    "title": "标题⚡string⚡1⚡200⚡''⚡0⚡null",
+    "description": "描述⚡string⚡0⚡500⚡''⚡0⚡null",
+    "keyword": "关键词⚡string⚡1⚡50⚡''⚡1⚡null",
     "status": "状态⚡string⚡1⚡20⚡active⚡1⚡^(active|inactive|pending|suspended)$",
     "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⚡0⚡10⚡[]⚡0⚡null"
+    "date": "日期⚡string⚡10⚡10⚡''⚡0⚡^\\d{4}-\\d{2}-\\d{2}$",
+    "datetime": "日期时间⚡string⚡19⚡25⚡''⚡0⚡^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}",
+    "filename": "文件名⚡string⚡1⚡255⚡''⚡0⚡null",
+    "url": "网址⚡string⚡5⚡500⚡''⚡0⚡^https?://",
+    "tag": "标签⚡array⚡0⚡10⚡''⚡0⚡null"
 }

package/tables/tool.json

@@ -1,6 +1,6 @@
 {
-    "filename": "文件名⚡string⚡1⚡255⚡null⚡1⚡null",
-    "content": "内容⚡string⚡0⚡100⚡null⚡0⚡null",
+    "filename": "文件名⚡string⚡1⚡255⚡''⚡1⚡null",
+    "content": "内容⚡string⚡0⚡100⚡''⚡0⚡null",
     "type": "类型⚡string⚡0⚡50⚡file⚡1⚡^(file|folder|link)$",
-    "path": "路径⚡string⚡1⚡500⚡null⚡0⚡null"
+    "path": "路径⚡string⚡1⚡500⚡''⚡0⚡null"
 }

package/utils/index.js

@@ -44,17 +44,26 @@ export const sortPlugins = (plugins) => {
     return isPass ? result : false;
 };
 
-// 规则分割
-export const ruleSplit = (rule) => {
-    const allParts = rule.split(',');
+/**
+ * 解析字段规则字符串（以 ⚡ 分隔），并进行最小类型转换：
+ * - 返回顺序：显示名, 类型, 最小值, 最大值, 默认值, 是否索引, 正则
+ * - 最小值/最大值/是否索引：当不为字面量字符串 'null' 时转为数字；否则保留原值
+ * - 默认值：当类型为 number 且默认值不为 'null' 时转为数字；否则保留原值
+ * - 不做正确性校验（由 checks/table.js 负责）
+ * - 保留额外段位（>7）以便上层可检测异常长度
+ *
+ * @param {string} rule
+ * @returns {any[]} 一个数组，至少包含前7段（若原始段位不足则按原样长度返回），多余段位将原样附加
+ */
+export const parseRule = (rule) => {
+    let [fieldName, fieldType, fieldMin, fieldMax, fieldDefault, fieldIndex, fieldRegx] = rule.split('⚡');
 
-    // 如果部分数量小于等于5，直接返回
-    if (allParts.length <= 5) {
-        return allParts;
-    }
+    fieldIndex = Number(fieldIndex);
+    if (fieldMin !== 'null') fieldMin = Number(fieldMin);
+    if (fieldMax !== 'null') fieldMax = Number(fieldMax);
+    if (fieldType !== 'number') fieldDefault = Number(fieldDefault);
 
-    // 只取前4个部分，剩余的都合并为第5个部分
-    return [allParts[0], allParts[1], allParts[2], allParts[3], allParts.slice(4).join(',')];
+    return [fieldName, fieldType, fieldMin, fieldMax, fieldDefault, fieldIndex, fieldRegx];
 };
 
 export const formatDate = (date = new Date(), format = 'YYYY-MM-DD HH:mm:ss') => {
@@ -140,27 +149,6 @@ export const pickFields = (obj, keys) => {
     return result;
 };
 
-/**
- * 从对象或数组数据中按“字段名”和“字段值”进行排除过滤。
- * - 支持对象：移除指定字段名，以及值在排除值列表中的字段。
- * - 支持数组：
- *   - 如果元素为对象，按同样规则清洗（移除字段名/字段值命中项）。
- *   - 如果元素为原始值（数字/字符串等），当元素值命中排除值则从数组中移除该元素。
- *
- * 约定：excludeKeys 与 excludeValues 均为数组类型。
- *
- * 示例：
- *   omitFields({ a:1, b:undefined, c:null }, ['a'], [undefined]) -> { c:null }
- *   omitFields([{ a:1, b:null }, null, 0], ['a'], [null]) -> [{}, 0]
- *
- * 注意：仅当第一个参数为对象或数组时执行过滤，否则原样返回。
- *
- * @template T
- * @param {Record<string, any> | Array<any>} data - 原始数据（对象或数组）
- * @param {string[]} [excludeKeys=[]] - 要排除的字段名（对象属性名）数组
- * @param {any[]} [excludeValues=[]] - 要排除的字段值数组；当包含 undefined/null 等时，将移除这些值对应的字段或数组元素
- * @returns {T} 过滤后的数据，类型与入参保持一致
- */
 export const omitFields = (data, excludeKeys = [], excludeValues = []) => {
     const shouldDropValue = (v) => excludeValues.some((x) => x === v);
 
@@ -176,15 +164,15 @@ export const omitFields = (data, excludeKeys = [], excludeValues = []) => {
     };
 
     if (isType(data, 'array')) {
-        return /** @type {any} */ (data.filter((item) => !shouldDropValue(item)).map((item) => (isType(item, 'object') ? cleanObject(item) : item)));
+        return data.filter((item) => !shouldDropValue(item)).map((item) => (isType(item, 'object') ? cleanObject(item) : item));
     }
 
     if (isType(data, 'object')) {
-        return /** @type {any} */ (cleanObject(data));
+        return cleanObject(data);
     }
 
     // 非对象/数组则原样返回（不处理）
-    return /** @type {any} */ (data);
+    return data;
 };
 
 export const isEmptyObject = (obj) => {
@@ -255,117 +243,86 @@ export const filterLogFields = (body, excludeFields = '') => {
     return filtered;
 };
 
-// 验证字段名称：中文、数字、字母、空格、下划线、短横线
-export const validateFieldName = (name) => {
-    const nameRegex = /^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/;
-    return nameRegex.test(name);
-};
-
-// 验证字段类型是否为指定的四种类型之一
-export const validateFieldType = (type) => {
-    const validTypes = ['string', 'number', 'text', 'array'];
-    return validTypes.includes(type);
+// 将 lowerCamelCase 或单词形式转换为下划线风格（snake_case）
+// 例如：userTable -> user_table, testNewFormat -> test_new_format, users -> users, orderV2 -> order_v2
+export const toSnakeTableName = (name) => {
+    if (!name) return name;
+    return String(name)
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, '$1_$2')
+        .toLowerCase();
 };
 
-// 验证最小值/最大值是否为null或数字
-export const validateMinMax = (value) => {
-    return value === 'null' || (!isNaN(parseFloat(value)) && isFinite(parseFloat(value)));
-};
-
-// 验证默认值是否为null、字符串或数字
-export const validateDefaultValue = (value) => {
-    if (value === 'null') return true;
-    // 检查是否为数字
-    if (!isNaN(parseFloat(value)) && isFinite(parseFloat(value))) return true;
-    // 其他情况视为字符串，都是有效的
-    return true;
-};
-
-// 验证索引标识是否为0或1
-export const validateIndex = (value) => {
-    return value === '0' || value === '1';
-};
-
-// 验证正则表达式是否有效
-export const validateRegex = (value) => {
-    if (value === 'null') return true;
-    try {
-        new RegExp(value);
-        return true;
-    } catch (e) {
-        return false;
-    }
-};
-
-// 专门用于处理⚡分隔的字段规则
-export const parseFieldRule = (rule) => {
-    const allParts = rule.split('⚡');
-
-    // 必须包含7个部分：显示名⚡类型⚡最小值⚡最大值⚡默认值⚡是否索引⚡正则约束
-    if (allParts.length !== 7) {
-        throw new Error(`字段规则格式错误，必须包含7个部分，当前包含${allParts.length}个部分`);
-    }
-
-    // 验证各个部分的格式
-    const [name, type, minValue, maxValue, defaultValue, isIndex, regexConstraint] = allParts;
-
-    // 第1个值：名称必须为中文、数字、字母
-    if (!validateFieldName(name)) {
-        throw new Error(`字段名称 "${name}" 格式错误，必须为中文、数字、字母`);
-    }
-
-    // 第2个值：字段类型必须为string,number,text,array之一
-    if (!validateFieldType(type)) {
-        throw new Error(`字段类型 "${type}" 格式错误，必须为string、number、text、array之一`);
-    }
-
-    // 第3个值：最小值必须为null或数字
-    if (!validateMinMax(minValue)) {
-        throw new Error(`最小值 "${minValue}" 格式错误，必须为null或数字`);
-    }
-
-    // 第4个值：最大值必须为null或数字
-    if (!validateMinMax(maxValue)) {
-        throw new Error(`最大值 "${maxValue}" 格式错误，必须为null或数字`);
-    }
+/**
+ * 创建并校验 Bun SQL 客户端
+ * - 连接成功后返回 SQL 实例，失败会自动 close 并抛出
+ * @param {object} options 传给 new SQL 的参数（如 { max: 1, bigint: true }）
+ */
 
-    // 第5个值：默认值必须为null、字符串或数字
-    if (!validateDefaultValue(defaultValue)) {
-        throw new Error(`默认值 "${defaultValue}" 格式错误，必须为null、字符串或数字`);
+// 组合最终数据库连接串：
+// - 基于 DB_* 环境变量构建（DB_TYPE/DB_HOST/DB_PORT/DB_USER/DB_PASS/DB_NAME）
+// - sqlite: sqlite:<DB_NAME>（文件路径或 :memory:）
+// - postgresql: postgres://[user:pass@]host:port/DB_NAME
+// - mysql: mysql://[user:pass@]host:port/DB_NAME
+export const buildDatabaseUrl = () => {
+    const type = Env.DB_TYPE || '';
+    const host = Env.DB_HOST || '';
+    const port = Env.DB_PORT;
+    const user = encodeURIComponent(Env.DB_USER || '');
+    const pass = encodeURIComponent(Env.DB_PASS || '');
+    const name = Env.DB_NAME || '';
+
+    if (!type) throw new Error('DB_TYPE 未配置');
+    if (!name && type !== 'sqlite') throw new Error('DB_NAME 未配置');
+
+    if (type === 'sqlite') {
+        if (!name) throw new Error('DB_NAME 未配置');
+        return `sqlite://${name}`;
     }
 
-    // 第6个值：是否创建索引必须为0或1
-    if (!validateIndex(isIndex)) {
-        throw new Error(`索引标识 "${isIndex}" 格式错误，必须为0或1`);
+    if (type === 'postgresql' || type === 'postgres') {
+        if (!host || !port) throw new Error('DB_HOST/DB_PORT 未配置');
+        const auth = user || pass ? `${user}:${pass}@` : '';
+        return `postgres://${auth}${host}:${port}/${encodeURIComponent(name)}`;
     }
 
-    // 第7个值：必须为null或正则表达式
-    if (!validateRegex(regexConstraint)) {
-        throw new Error(`正则约束 "${regexConstraint}" 格式错误，必须为null或有效的正则表达式`);
+    if (type === 'mysql') {
+        if (!host || !port) throw new Error('DB_HOST/DB_PORT 未配置');
+        const auth = user || pass ? `${user}:${pass}@` : '';
+        return `mysql://${auth}${host}:${port}/${encodeURIComponent(name)}`;
     }
 
-    return allParts;
+    throw new Error(`不支持的 DB_TYPE: ${type}`);
 };
 
-/**
- * 创建并校验 Bun SQL 客户端
- * - 否则按 scripts/syncDb.js 的方式拼接 URL
- * - 连接成功后返回 SQL 实例，失败会自动 close 并抛出
- * @param {object} options 传给 new SQL 的参数（如 { max: 1, bigint: true }）
- */
 export async function createSqlClient(options = {}) {
-    const url = `mysql://${encodeURIComponent(Env.MYSQL_USER)}:${encodeURIComponent(Env.MYSQL_PASSWORD)}@${Env.MYSQL_HOST}:${Env.MYSQL_PORT}/${Env.MYSQL_DB}`;
-
-    const sql = new SQL({
-        url: url,
-        max: options.max ?? 1,
-        bigint: options.bigint ?? true,
-        ...options
-    });
+    const finalUrl = buildDatabaseUrl();
+    let sql = null;
+    if (Env.DB_TYPE === 'sqlite') {
+        sql = new SQL(finalUrl);
+    } else {
+        sql = new SQL({
+            url: finalUrl,
+            max: options.max ?? 1,
+            bigint: options.bigint ?? true,
+            ...options
+        });
+    }
+
     try {
-        const ver = await sql`SELECT VERSION() AS version`;
-        const version = ver?.[0]?.version;
-        Logger.info(`数据库连接成功，MySQL 版本: ${version}`);
+        // 连接健康检查：按协议选择
+        let version = '';
+        if (Env.DB_TYPE === 'sqlite') {
+            const v = await sql`SELECT sqlite_version() AS version`;
+            version = v?.[0]?.version;
+        } else if (Env.DB_TYPE === 'postgresql' || Env.DB_TYPE === 'postgres') {
+            const v = await sql`SELECT version() AS version`;
+            version = v?.[0]?.version;
+        } else {
+            const v = await sql`SELECT VERSION() AS version`;
+            version = v?.[0]?.version;
+        }
+        Logger.info(`数据库连接成功，version: ${version}`);
         return sql;
     } catch (error) {
         Logger.error('数据库连接测试失败:', error);

package/utils/sqlManager.js

@@ -71,7 +71,7 @@ export class SqlManager {
         const isWriteLike = /^\s*(insert|update|delete|replace)\b/i.test(query);
         const client = conn || this.#sql;
         try {
-            if (Env.MYSQL_DEBUG === 1) {
+            if (Env.DB_DEBUG === 1) {
                 Logger.debug('执行SQL:', { sql: query, params });
             }
             // 读查询

package/utils/validate.js

@@ -1,6 +1,4 @@
-import { isType, parseFieldRule } from './index.js';
-
-// 移除本文件重复实现，统一复用 index.js 导出的校验函数与 parseFieldRule
+import { isType, parseRule } from './index.js';
 
 /**
  * 验证器类
@@ -65,8 +63,8 @@ export class Validator {
         for (const fieldName of required) {
             if (!(fieldName in data) || data[fieldName] === undefined || data[fieldName] === null || data[fieldName] === '') {
                 result.code = 1;
-                const ruleParts = parseFieldRule(rules[fieldName] || '');
-                const fieldLabel = ruleParts[0] || fieldName;
+                const ruleParts = parseRule(rules[fieldName] || '');
+                const fieldLabel = (ruleParts && ruleParts[0]) || fieldName;
                 result.fields[fieldName] = `${fieldLabel}(${fieldName})为必填项`;
             }
         }
@@ -101,10 +99,10 @@ export class Validator {
      * 验证单个字段的值
      */
     validateFieldValue(value, rule, fieldName) {
-        const [name, type, minStr, maxStr, defaultValue, isIndexStr, regexConstraint] = parseFieldRule(rule);
-        const min = minStr === 'null' ? null : parseInt(minStr) || 0;
-        const max = maxStr === 'null' ? null : parseInt(maxStr) || 0;
-        const spec = regexConstraint === 'null' ? null : regexConstraint.trim();
+        const [name, type, minRaw, maxRaw, defaultValue, isIndexRaw, regexConstraint] = parseRule(rule);
+        const min = minRaw === 'null' ? null : /** @type {number} */ (typeof minRaw === 'number' ? minRaw : Number(minRaw));
+        const max = maxRaw === 'null' ? null : /** @type {number} */ (typeof maxRaw === 'number' ? maxRaw : Number(maxRaw));
+        const spec = regexConstraint === 'null' ? null : String(regexConstraint).trim();
 
         switch (type.toLowerCase()) {
             case 'number':