befly 2.1.1 → 2.2.1

package/plugins/redis.js

@@ -1,78 +1,20 @@
 import { redis } from 'bun';
 import { Env } from '../config/env.js';
 import { Logger } from '../utils/logger.js';
+import { RedisHelper, getRedisClient } from '../utils/redisHelper.js';
 
 export default {
     after: ['_logger'],
     async onInit(befly) {
         try {
             if (Env.REDIS_ENABLE === 1) {
-                if ((await redis.ping()) !== 'PONG') {
+                const client = getRedisClient();
+                if ((await client.ping()) !== 'PONG') {
                     throw new Error('Redis 连接失败');
                 }
 
-                return {
-                    // 添加对象存储辅助方法
-                    setObject: async (key, obj, ttl = null) => {
-                        try {
-                            const data = JSON.stringify(obj);
-                            if (ttl) {
-                                return await redis.setEx(`${process.env.REDIS_KEY_PREFIX}:${key}`, ttl, data);
-                            }
-                            return await redis.set(`${process.env.REDIS_KEY_PREFIX}:${key}`, data);
-                        } catch (error) {
-                            Logger.error({
-                                msg: 'Redis setObject 错误',
-                                message: error.message,
-                                stack: error.stack
-                            });
-                        }
-                    },
-
-                    getObject: async (key) => {
-                        try {
-                            const data = await redis.get(`${process.env.REDIS_KEY_PREFIX}:${key}`);
-                            return data ? JSON.parse(data) : null;
-                        } catch (error) {
-                            Logger.error({
-                                msg: 'Redis getObject 错误',
-                                message: error.message,
-                                stack: error.stack
-                            });
-                            return null;
-                        }
-                    },
-
-                    delObject: async (key) => {
-                        try {
-                            await redis.del(`${process.env.REDIS_KEY_PREFIX}:${key}`);
-                        } catch (error) {
-                            Logger.error({
-                                msg: 'Redis delObject 错误',
-                                message: error.message,
-                                stack: error.stack
-                            });
-                        }
-                    },
-
-                    // 添加时序ID生成函数
-                    genTimeID: async () => {
-                        const timestamp = Math.floor(Date.now() / 1000);
-                        const key = `time_id_counter:${timestamp}`;
-
-                        const counter = await redis.incr(key);
-                        await redis.expire(key, 2);
-
-                        // 前3位计数器 + 后3位随机数
-                        const counterPrefix = (counter % 1000).toString().padStart(3, '0'); // 000-999
-                        const randomSuffix = Math.floor(Math.random() * 1000)
-                            .toString()
-                            .padStart(3, '0'); // 000-999
-                        const suffix = `${counterPrefix}${randomSuffix}`;
-
-                        return Number(`${timestamp}${suffix}`);
-                    }
-                };
+                // 返回工具对象，向下游以相同 API 暴露
+                return RedisHelper;
             } else {
                 Logger.warn(`Redis 未启用，跳过初始化`);
                 return {};
@@ -83,7 +25,8 @@ export default {
                 message: err.message,
                 stack: err.stack
             });
-            process.exit();
+            // 插件内禁止直接退出进程，抛出异常交由主流程统一处理
+            throw err;
         }
     }
 };

package/plugins/tool.js

@@ -1,45 +1,8 @@
+import { Tool } from '../utils/tool.js';
+
 export default {
     after: ['_redis', '_db'],
     async onInit(befly) {
-        // 增强的更新方法 - 自动添加 updated_at
-
-        // 辅助函数：过滤掉 undefined 值和指定字段
-        const filterData = (obj, excludeFields = []) => {
-            return Object.fromEntries(Object.entries(obj).filter(([key, value]) => value !== undefined && !excludeFields.includes(key)));
-        };
-
-        return {
-            async updData(data) {
-                const updateData = {
-                    ...filterData(data, ['id', 'created_at', 'deleted_at']),
-                    updated_at: Date.now()
-                };
-
-                return updateData;
-            },
-            async insData(data) {
-                const now = Date.now();
-
-                if (Array.isArray(data)) {
-                    const data2 = await Promise.all(
-                        data.map(async (item) => ({
-                            ...filterData(item),
-                            id: await befly.redis.genTimeID(),
-                            created_at: now,
-                            updated_at: now
-                        }))
-                    );
-                    return data2;
-                } else {
-                    const data2 = {
-                        ...filterData(data),
-                        id: await befly.redis.genTimeID(),
-                        created_at: now,
-                        updated_at: now
-                    };
-                    return data2;
-                }
-            }
-        };
+        return new Tool(befly);
     }
 };

package/scripts/syncDb.js

@@ -3,12 +3,11 @@
  */
 
 import path from 'node:path';
-import { SQL } from 'bun';
 import { Env } from '../config/env.js';
 import { Logger } from '../utils/logger.js';
-import { parseFieldRule } from '../utils/util.js';
+import { parseFieldRule, createSqlClient } from '../utils/index.js';
 import { __dirtables, getProjectDir } from '../system.js';
-import tableCheck from '../checks/table.js';
+import { checkTable } from '../checks/table.js';
 
 const typeMapping = {
     number: 'BIGINT',
@@ -54,16 +53,10 @@ const getColumnDefinition = (fieldName, rule) => {
     return columnDef;
 };
 
-// 通用执行器：将 '?' 占位符转换为 Bun SQL 的 $1, $2 并执行
-const toDollarParams = (query, params) => {
-    if (!params || params.length === 0) return query;
-    let i = 0;
-    return query.replace(/\?/g, () => `$${++i}`);
-};
-
+// 通用执行器：直接使用 Bun SQL 参数化（MySQL 使用 '?' 占位符）
 const exec = async (client, query, params = []) => {
-    if (params.length > 0) {
-        return await client.unsafe(toDollarParams(query, params), params);
+    if (params && params.length > 0) {
+        return await client.unsafe(query, params);
     }
     return await client.unsafe(query);
 };
@@ -277,14 +270,13 @@ const SyncDb = async () => {
         Logger.info('开始数据库表结构同步...');
 
         // 验证表定义文件
-        const tableValidationResult = await tableCheck();
+        const tableValidationResult = await checkTable();
         if (!tableValidationResult) {
             throw new Error('表定义验证失败');
         }
 
-        // 建立数据库连接并检查版本（Bun SQL）
-        const url = `mysql://${encodeURIComponent(Env.MYSQL_USER || 'root')}:${encodeURIComponent(Env.MYSQL_PASSWORD || 'root')}@${Env.MYSQL_HOST || '127.0.0.1'}:${Env.MYSQL_PORT || 3306}/${Env.MYSQL_DB || 'test'}`;
-        client = new SQL({ url, max: 1, bigint: true });
+        // 建立数据库连接并检查版本（统一工具函数）
+        client = await createSqlClient({ max: 1 });
         const result = await client`SELECT VERSION() AS version`;
         const version = result[0].version;
 

package/utils/api.js

@@ -1,5 +1,5 @@
 import { Logger } from './logger.js';
-import { RYes, RNo } from './util.js';
+import { RYes, RNo } from './index.js';
 export class Api {
     // GET 方法
     static GET(name, auth = false, fields = {}, required = [], handler) {

package/utils/{util.js → index.js}

@@ -1,6 +1,8 @@
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
+import { SQL } from 'bun';
 import { Env } from '../config/env.js';
+import { Logger } from './logger.js';
 
 export const setCorsOptions = (req) => {
     return {
@@ -73,7 +75,7 @@ export const formatDate = (date = new Date(), format = 'YYYY-MM-DD HH:mm:ss') =>
  * @param {number} endTime - 结束时间（可选，默认为当前时间）
  * @returns {string} 时间差（如果小于1秒返回"xx 毫秒"，否则返回"xx 秒"）
  */
-export const calculateElapsedTime = (startTime, endTime = Bun.nanoseconds()) => {
+export const calcPerfTime = (startTime, endTime = Bun.nanoseconds()) => {
     const elapsedMs = (endTime - startTime) / 1_000_000;
 
     if (elapsedMs < 1000) {
@@ -87,16 +89,12 @@ export const calculateElapsedTime = (startTime, endTime = Bun.nanoseconds()) =>
 // 类型判断
 export const isType = (value, type) => {
     const actualType = Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
-    const expectedType = type.toLowerCase();
+    const expectedType = String(type).toLowerCase();
 
-    // 特殊类型处理
+    // 语义类型单独处理，其余走 actualType === expectedType
     switch (expectedType) {
-        case 'null':
-            return value === null;
-        case 'undefined':
-            return value === undefined;
         case 'nan':
-            return Number.isNaN(value);
+            return typeof value === 'number' && Number.isNaN(value);
         case 'empty':
             return value === '' || value === null || value === undefined;
         case 'integer':
@@ -117,15 +115,14 @@ export const isType = (value, type) => {
             return value !== Object(value);
         case 'reference':
             return value === Object(value);
-        case 'function':
-            return typeof value === 'function';
         default:
             return actualType === expectedType;
     }
 };
 
 export const pickFields = (obj, keys) => {
-    if (!obj || typeof obj !== 'object') {
+    // 仅对对象或数组进行字段挑选，其他类型返回空对象（保持原有行为）
+    if (!obj || (!isType(obj, 'object') && !isType(obj, 'array'))) {
         return {};
     }
 
@@ -140,25 +137,56 @@ export const pickFields = (obj, keys) => {
     return result;
 };
 
-export const omitFields = (obj, keys) => {
-    if (!obj || typeof obj !== 'object' || !Array.isArray(keys)) {
-        return {};
-    }
+/**
+ * 从对象或数组数据中按“字段名”和“字段值”进行排除过滤。
+ * - 支持对象：移除指定字段名，以及值在排除值列表中的字段。
+ * - 支持数组：
+ *   - 如果元素为对象，按同样规则清洗（移除字段名/字段值命中项）。
+ *   - 如果元素为原始值（数字/字符串等），当元素值命中排除值则从数组中移除该元素。
+ *
+ * 约定：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);
+
+    const cleanObject = (obj) => {
+        if (!isType(obj, 'object')) return obj;
+        const result = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (excludeKeys.includes(k)) continue;
+            if (shouldDropValue(v)) continue;
+            result[k] = v;
+        }
+        return result;
+    };
 
-    const result = {};
+    if (isType(data, 'array')) {
+        return /** @type {any} */ (data.filter((item) => !shouldDropValue(item)).map((item) => (isType(item, 'object') ? cleanObject(item) : item)));
+    }
 
-    for (const key in obj) {
-        if (obj.hasOwnProperty(key) && !keys.includes(key)) {
-            result[key] = obj[key];
-        }
+    if (isType(data, 'object')) {
+        return /** @type {any} */ (cleanObject(data));
     }
 
-    return result;
+    // 非对象/数组则原样返回（不处理）
+    return /** @type {any} */ (data);
 };
 
 export const isEmptyObject = (obj) => {
     // 首先检查是否为对象
-    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+    if (!isType(obj, 'object')) {
         return false;
     }
 
@@ -168,7 +196,7 @@ export const isEmptyObject = (obj) => {
 
 export const isEmptyArray = (arr) => {
     // 首先检查是否为数组
-    if (!Array.isArray(arr)) {
+    if (!isType(arr, 'array')) {
         return false;
     }
 
@@ -205,7 +233,8 @@ export const dirname2 = (importMetaUrl) => {
 
 // 过滤日志字段的函数
 export const filterLogFields = (body, excludeFields = '') => {
-    if (!body || typeof body !== 'object') return body;
+    // 仅在对象或数组时进行过滤，保持与原 typeof === 'object' 行为一致（数组也会进入）
+    if (!body || (!isType(body, 'object') && !isType(body, 'array'))) return body;
 
     // 如果是字符串，按逗号分割并清理空格
     const fieldsArray = excludeFields
@@ -314,3 +343,32 @@ export const parseFieldRule = (rule) => {
 
     return allParts;
 };
+
+/**
+ * 创建并校验 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
+    });
+    try {
+        const ver = await sql`SELECT VERSION() AS version`;
+        const version = ver?.[0]?.version;
+        Logger.info(`数据库连接成功，MySQL 版本: ${version}`);
+        return sql;
+    } catch (error) {
+        Logger.error('数据库连接测试失败:', error);
+        try {
+            await sql.close();
+        } catch {}
+        throw error;
+    }
+}

package/utils/jwt.js

@@ -1,4 +1,4 @@
-import { Jwt as JwtBase } from '../libs/jwt.js';
+import { createHmac } from 'crypto';
 import { Env } from '../config/env.js';
 
 /**
@@ -6,6 +6,54 @@ import { Env } from '../config/env.js';
  * 提供JWT token的签名、验证和解码功能以及应用层的便捷接口
  */
 export class Jwt {
+    // 原基础工具：算法映射
+    static ALGORITHMS = {
+        HS256: 'sha256',
+        HS384: 'sha384',
+        HS512: 'sha512'
+    };
+
+    // 原基础工具：Base64 URL 编解码
+    static base64UrlEncode(input) {
+        const base64 = Buffer.isBuffer(input) ? input.toString('base64') : Buffer.from(input, 'utf8').toString('base64');
+        return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    }
+    static base64UrlDecode(str) {
+        const padding = 4 - (str.length % 4);
+        if (padding !== 4) str += '='.repeat(padding);
+        str = str.replace(/-/g, '+').replace(/_/g, '/');
+        return Buffer.from(str, 'base64').toString('utf8');
+    }
+
+    // 原基础工具：过期时间解析与签名/比较
+    static parseExpiration(expiresIn) {
+        if (typeof expiresIn === 'number') return expiresIn;
+        if (typeof expiresIn !== 'string') throw new Error('过期时间格式无效');
+        const numericValue = parseInt(expiresIn);
+        if (!isNaN(numericValue) && numericValue.toString() === expiresIn) return numericValue;
+        const match = expiresIn.match(/^(\d+)(ms|[smhdwy])$/);
+        if (!match) throw new Error('过期时间格式无效');
+        const value = parseInt(match[1]);
+        const unit = match[2];
+        if (unit === 'ms') return Math.floor(value / 1000);
+        const multipliers = { s: 1, m: 60, h: 3600, d: 86400, w: 604800, y: 31536000 };
+        return value * multipliers[unit];
+    }
+    static createSignature(algorithm, secret, data) {
+        const hashAlgorithm = this.ALGORITHMS[algorithm];
+        if (!hashAlgorithm) throw new Error(`不支持的算法: ${algorithm}`);
+        const hmac = createHmac(hashAlgorithm, secret);
+        hmac.update(data);
+        return this.base64UrlEncode(hmac.digest());
+    }
+    static constantTimeCompare(a, b) {
+        if (a.length !== b.length) return false;
+        let result = 0;
+        for (let i = 0; i < a.length; i++) {
+            result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+        }
+        return result === 0;
+    }
     /**
      * 签名JWT token
      * @param {object} payload - JWT载荷数据
@@ -26,7 +74,7 @@ export class Jwt {
         const now = Math.floor(Date.now() / 1000);
 
         // 创建header
-        const header = JwtBase.base64UrlEncode(
+        const header = Jwt.base64UrlEncode(
             JSON.stringify({
                 alg: algorithm,
                 typ: 'JWT'
@@ -37,22 +85,22 @@ export class Jwt {
         const jwtPayload = { ...payload, iat: now };
 
         if (options.expiresIn || Env.JWT_EXPIRES_IN) {
-            const expSeconds = JwtBase.parseExpiration(options.expiresIn || Env.JWT_EXPIRES_IN);
+            const expSeconds = Jwt.parseExpiration(options.expiresIn || Env.JWT_EXPIRES_IN);
             jwtPayload.exp = now + expSeconds;
         }
         if (options.issuer) jwtPayload.iss = options.issuer;
         if (options.audience) jwtPayload.aud = options.audience;
         if (options.subject) jwtPayload.sub = options.subject;
         if (options.notBefore) {
-            jwtPayload.nbf = typeof options.notBefore === 'number' ? options.notBefore : now + JwtBase.parseExpiration(options.notBefore);
+            jwtPayload.nbf = typeof options.notBefore === 'number' ? options.notBefore : now + Jwt.parseExpiration(options.notBefore);
         }
         if (options.jwtId) jwtPayload.jti = options.jwtId;
 
-        const encodedPayload = JwtBase.base64UrlEncode(JSON.stringify(jwtPayload));
+        const encodedPayload = Jwt.base64UrlEncode(JSON.stringify(jwtPayload));
 
         // 创建签名
         const data = `${header}.${encodedPayload}`;
-        const signature = JwtBase.createSignature(algorithm, secret, data);
+        const signature = Jwt.createSignature(algorithm, secret, data);
 
         return `${data}.${signature}`;
     }
@@ -80,20 +128,20 @@ export class Jwt {
 
         try {
             // 解析header和payload
-            const header = JSON.parse(JwtBase.base64UrlDecode(parts[0]));
-            const payload = JSON.parse(JwtBase.base64UrlDecode(parts[1]));
+            const header = JSON.parse(Jwt.base64UrlDecode(parts[0]));
+            const payload = JSON.parse(Jwt.base64UrlDecode(parts[1]));
             const signature = parts[2];
 
             // 验证算法
-            if (!JwtBase.ALGORITHMS[header.alg]) {
+            if (!Jwt.ALGORITHMS[header.alg]) {
                 throw new Error(`不支持的算法: ${header.alg}`);
             }
 
             // 验证签名
             const data = `${parts[0]}.${parts[1]}`;
-            const expectedSignature = JwtBase.createSignature(header.alg, secret, data);
+            const expectedSignature = Jwt.createSignature(header.alg, secret, data);
 
-            if (!JwtBase.constantTimeCompare(signature, expectedSignature)) {
+            if (!Jwt.constantTimeCompare(signature, expectedSignature)) {
                 throw new Error('Token签名无效');
             }
 
@@ -147,8 +195,8 @@ export class Jwt {
         }
 
         try {
-            const header = JSON.parse(JwtBase.base64UrlDecode(parts[0]));
-            const payload = JSON.parse(JwtBase.base64UrlDecode(parts[1]));
+            const header = JSON.parse(Jwt.base64UrlDecode(parts[0]));
+            const payload = JSON.parse(Jwt.base64UrlDecode(parts[1]));
 
             return complete ? { header, payload, signature: parts[2] } : payload;
         } catch (error) {
@@ -335,3 +383,5 @@ export class Jwt {
         return timeToExpiry > 0 && timeToExpiry <= thresholdSeconds;
     }
 }
+
+// 已使用 `export class Jwt` 具名导出

package/utils/logger.js

@@ -1,6 +1,6 @@
 import path from 'path';
 import { appendFile, stat } from 'node:fs/promises';
-import { formatDate } from './util.js';
+import { formatDate } from './index.js';
 import { Env } from '../config/env.js';
 
 export class Logger {

package/utils/redisHelper.js

@@ -0,0 +1,74 @@
+import { redis as bunRedis } from 'bun';
+import { Env } from '../config/env.js';
+import { Logger } from './logger.js';
+
+const prefix = Env.REDIS_KEY_PREFIX ? `${Env.REDIS_KEY_PREFIX}:` : '';
+
+let redisClient = bunRedis;
+export const setRedisClient = (client) => {
+    redisClient = client || bunRedis;
+};
+export const getRedisClient = () => redisClient;
+
+export const RedisHelper = {
+    async setObject(key, obj, ttl = null) {
+        try {
+            const data = JSON.stringify(obj);
+            const pkey = `${prefix}${key}`;
+            if (ttl) {
+                return await redisClient.setEx(pkey, ttl, data);
+            }
+            return await redisClient.set(pkey, data);
+        } catch (error) {
+            Logger.error({
+                msg: 'Redis setObject 错误',
+                message: error.message,
+                stack: error.stack
+            });
+        }
+    },
+
+    async getObject(key) {
+        try {
+            const pkey = `${prefix}${key}`;
+            const data = await redisClient.get(pkey);
+            return data ? JSON.parse(data) : null;
+        } catch (error) {
+            Logger.error({
+                msg: 'Redis getObject 错误',
+                message: error.message,
+                stack: error.stack
+            });
+            return null;
+        }
+    },
+
+    async delObject(key) {
+        try {
+            const pkey = `${prefix}${key}`;
+            await redisClient.del(pkey);
+        } catch (error) {
+            Logger.error({
+                msg: 'Redis delObject 错误',
+                message: error.message,
+                stack: error.stack
+            });
+        }
+    },
+
+    async genTimeID() {
+        const timestamp = Math.floor(Date.now() / 1000);
+        const key = `${prefix}time_id_counter:${timestamp}`;
+
+        const counter = await redisClient.incr(key);
+        await redisClient.expire(key, 2);
+
+        const counterPrefix = (counter % 1000).toString().padStart(3, '0');
+        const randomSuffix = Math.floor(Math.random() * 1000)
+            .toString()
+            .padStart(3, '0');
+        const suffix = `${counterPrefix}${randomSuffix}`;
+
+        return Number(`${timestamp}${suffix}`);
+    }
+};