befly 0.1.26

package/utils/jwt.js

@@ -0,0 +1,154 @@
+import { Env } from '../config/env.js';
+
+/**
+ * JWT 工具类
+ */
+export class Jwt {
+    static signer = null;
+    static verifier = null;
+    static initialized = false;
+
+    /**
+     * 初始化 JWT 工具
+     */
+    static async init() {
+        if (this.initialized) return;
+
+        const { createSigner, createVerifier } = await import('fast-jwt');
+
+        this.signer = createSigner({
+            key: Env.JWT_SECRET,
+            expiresIn: Env.JWT_EXPIRES_IN || '7d',
+            algorithm: Env.JWT_ALGORITHM || 'HS256'
+        });
+
+        this.verifier = createVerifier({
+            key: Env.JWT_SECRET,
+            algorithms: [Env.JWT_ALGORITHM || 'HS256']
+        });
+
+        this.initialized = true;
+    }
+
+    /**
+     * 签名 JWT token
+     * @param {object} payload - JWT 载荷
+     * @returns {Promise<string>} JWT token
+     */
+    static async sign(payload) {
+        await this.init();
+        return this.signer(payload);
+    }
+
+    /**
+     * 验证 JWT token
+     * @param {string} token - JWT token
+     * @returns {Promise<object>} 解码后的载荷
+     */
+    static async verify(token) {
+        await this.init();
+        return this.verifier(token);
+    }
+
+    /**
+     * 创建自定义签名器
+     * @param {object} options - 签名选项
+     * @returns {Promise<Function>} 签名器函数
+     */
+    static async createSigner(options = {}) {
+        const { createSigner } = await import('fast-jwt');
+        return createSigner({
+            key: options.key || Env.JWT_SECRET,
+            expiresIn: options.expiresIn || Env.JWT_EXPIRES_IN || '7d',
+            algorithm: options.algorithm || Env.JWT_ALGORITHM || 'HS256',
+            ...options
+        });
+    }
+
+    /**
+     * 创建自定义验证器
+     * @param {object} options - 验证选项
+     * @returns {Promise<Function>} 验证器函数
+     */
+    static async createVerifier(options = {}) {
+        const { createVerifier } = await import('fast-jwt');
+        return createVerifier({
+            key: options.key || Env.JWT_SECRET,
+            algorithms: options.algorithms || [Env.JWT_ALGORITHM || 'HS256'],
+            ...options
+        });
+    }
+
+    /**
+     * 解码 JWT token (不验证签名)
+     * @param {string} token - JWT token
+     * @returns {object} 解码后的内容
+     */
+    static decode(token) {
+        try {
+            const parts = token.split('.');
+            if (parts.length !== 3) {
+                throw new Error('Invalid JWT format');
+            }
+
+            const header = JSON.parse(atob(parts[0]));
+            const payload = JSON.parse(atob(parts[1]));
+
+            return { header, payload };
+        } catch (error) {
+            throw new Error('Failed to decode JWT: ' + error.message);
+        }
+    }
+
+    /**
+     * 检查 token 是否过期
+     * @param {string} token - JWT token
+     * @returns {boolean} 是否过期
+     */
+    static isExpired(token) {
+        try {
+            const { payload } = this.decode(token);
+            if (!payload.exp) return false;
+            return Date.now() >= payload.exp * 1000;
+        } catch {
+            return true;
+        }
+    }
+
+    /**
+     * 获取 token 剩余有效时间 (秒)
+     * @param {string} token - JWT token
+     * @returns {number} 剩余秒数，-1 表示已过期或无过期时间
+     */
+    static getTimeToExpiry(token) {
+        try {
+            const { payload } = this.decode(token);
+            if (!payload.exp) return -1;
+            const remaining = payload.exp - Math.floor(Date.now() / 1000);
+            return remaining > 0 ? remaining : -1;
+        } catch {
+            return -1;
+        }
+    }
+
+    /**
+     * 刷新 token (重新签名相同载荷)
+     * @param {string} token - 旧的 JWT token
+     * @returns {Promise<string>} 新的 JWT token
+     */
+    static async refresh(token) {
+        const { payload } = this.decode(token);
+        // 移除时间相关的声明，让新 token 重新生成
+        delete payload.iat;
+        delete payload.exp;
+        delete payload.nbf;
+        return this.sign(payload);
+    }
+}
+
+// 使用示例：
+// const token = await JWT.sign({ userId: 123, role: 'user' });
+// const payload = await JWT.verify(token);
+// const isExpired = JWT.isExpired(token);
+// const remaining = JWT.getTimeToExpiry(token);
+// const newToken = await JWT.refresh(token);

package/utils/logger.js

@@ -0,0 +1,143 @@
+import path from 'path';
+import { appendFile, stat } from 'node:fs/promises';
+import { formatDate } from './util.js';
+import { Env } from '../config/env.js';
+
+export class Logger {
+    // 静态属性
+    static level = Env.LOG_LEVEL || 'info';
+    static levels = {
+        error: 0,
+        warn: 1,
+        info: 2,
+        debug: 3
+    };
+    static logDir = Env.LOG_DIR || 'logs';
+    static maxFileSize = Env.LOG_MAX_SIZE || 50 * 1024 * 1024; // 50MB
+    static currentFiles = new Map(); // key: prefix, value: filepath
+
+    static formatMessage(level, message) {
+        const timestamp = formatDate();
+        const levelStr = level.toUpperCase().padStart(5);
+
+        let msg = `[${timestamp}] ${levelStr} - `;
+
+        if (Object.keys(message).length > 0) {
+            msg += `${JSON.stringify(message).replace(/\s+/g, ' ').replace(/\\"/g, '"').replace(/\\n/g, ' ')}`;
+        }
+
+        return msg;
+    }
+
+    static async log(level, message) {
+        // 内联 shouldLog 逻辑，检查日志级别
+        if (this.levels[level] > this.levels[this.level]) return;
+
+        const formattedMessage = this.formatMessage(level, message);
+
+        // 控制台输出
+        if (Env.LOG_TO_CONSOLE === 1) {
+            console.log(formattedMessage);
+        }
+
+        await this.writeToFile(formattedMessage, level);
+    }
+
+    static async writeToFile(message, level = 'info') {
+        try {
+            let prefix;
+
+            // debug 日志使用单独的文件名
+            if (level === 'debug') {
+                prefix = 'debug';
+            } else {
+                prefix = new Date().toISOString().split('T')[0];
+            }
+
+            // 检查缓存的当前文件是否仍然可用
+            let currentLogFile = this.currentFiles.get(prefix);
+
+            if (currentLogFile) {
+                try {
+                    const stats = await stat(currentLogFile);
+                    // 如果文件超过最大大小，清除缓存
+                    if (stats.size >= this.maxFileSize) {
+                        this.currentFiles.delete(prefix);
+                        currentLogFile = null;
+                    }
+                } catch (error) {
+                    // 文件不存在或无法访问，清除缓存
+                    this.currentFiles.delete(prefix);
+                    currentLogFile = null;
+                }
+            }
+
+            // 如果没有缓存的文件或文件已满，查找合适的文件
+            if (!currentLogFile) {
+                currentLogFile = await this.findAvailableLogFile(prefix);
+                this.currentFiles.set(prefix, currentLogFile);
+            }
+
+            // 使用 Node.js 的 appendFile 进行文件追加
+            await appendFile(currentLogFile, message + '\n', 'utf8');
+        } catch (error) {
+            console.error('写入日志文件失败:', error.message);
+        }
+    }
+
+    static async findAvailableLogFile(prefix) {
+        const glob = new Bun.Glob(`${prefix}.*.log`);
+        const files = await Array.fromAsync(glob.scan(this.logDir));
+
+        // 按文件名排序
+        files.sort((a, b) => {
+            const aNum = parseInt(a.match(/\.(\d+)\.log$/)?.[1] || '0');
+            const bNum = parseInt(b.match(/\.(\d+)\.log$/)?.[1] || '0');
+            return aNum - bNum;
+        });
+
+        // 从最后一个文件开始检查
+        for (let i = files.length - 1; i >= 0; i--) {
+            const filePath = path.join(this.logDir, files[i]);
+            try {
+                const stats = await stat(filePath);
+                if (stats.size < this.maxFileSize) {
+                    return filePath;
+                }
+            } catch (error) {
+                // 文件不存在或无法访问，跳过
+                continue;
+            }
+        }
+
+        // 所有文件都已满或没有文件，创建新文件
+        const nextIndex = files.length > 0 ? Math.max(...files.map((f) => parseInt(f.match(/\.(\d+)\.log$/)?.[1] || '0'))) + 1 : 0;
+
+        return path.join(this.logDir, `${prefix}.${nextIndex}.log`);
+    }
+
+    // 静态便捷方法
+    static async error(message) {
+        await this.log('error', message);
+    }
+
+    static async warn(message) {
+        await this.log('warn', message);
+    }
+
+    static async info(message) {
+        await this.log('info', message);
+    }
+
+    static async debug(message) {
+        // debug 级别必须记录，忽略级别检查
+        const formattedMessage = this.formatMessage('debug', message);
+
+        // 控制台输出
+        if (Env.LOG_TO_CONSOLE === 1) {
+            console.log(formattedMessage);
+        }
+
+        await this.writeToFile(formattedMessage, 'debug');
+    }
+}

package/utils/util.js

@@ -0,0 +1,171 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+export const sortPlugins = (plugins) => {
+    const result = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const pluginMap = Object.fromEntries(plugins.map((p) => [p.pluginName, p]));
+    let isPass = true;
+    const visit = (name) => {
+        if (visited.has(name)) return;
+        if (visiting.has(name)) {
+            isPass = false;
+            return;
+        }
+
+        const plugin = pluginMap[name];
+        if (!plugin) return; // 依赖不存在时跳过
+
+        visiting.add(name);
+        (plugin.after || []).forEach(visit);
+        visiting.delete(name);
+        visited.add(name);
+        result.push(plugin);
+    };
+
+    plugins.forEach((p) => visit(p.pluginName));
+    return isPass ? result : false;
+};
+
+// 规则分割
+export const ruleSplit = (rule) => {
+    const allParts = rule.split(',');
+
+    // 如果部分数量小于等于5，直接返回
+    if (allParts.length <= 5) {
+        return allParts;
+    }
+
+    // 只取前4个部分，剩余的都合并为第5个部分
+    return [allParts[0], allParts[1], allParts[2], allParts[3], allParts.slice(4).join(',')];
+};
+
+export const formatDate = (date = new Date(), format = 'YYYY-MM-DD HH:mm:ss') => {
+    const d = new Date(date);
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    const hour = String(d.getHours()).padStart(2, '0');
+    const minute = String(d.getMinutes()).padStart(2, '0');
+    const second = String(d.getSeconds()).padStart(2, '0');
+
+    return format.replace('YYYY', year).replace('MM', month).replace('DD', day).replace('HH', hour).replace('mm', minute).replace('ss', second);
+};
+
+// 类型判断
+export const isType = (value, type) => {
+    const actualType = Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
+    const expectedType = type.toLowerCase();
+
+    // 特殊类型处理
+    switch (expectedType) {
+        case 'null':
+            return value === null;
+        case 'undefined':
+            return value === undefined;
+        case 'nan':
+            return Number.isNaN(value);
+        case 'empty':
+            return value === '' || value === null || value === undefined;
+        case 'integer':
+            return Number.isInteger(value);
+        case 'float':
+            return typeof value === 'number' && !Number.isInteger(value) && !Number.isNaN(value);
+        case 'positive':
+            return typeof value === 'number' && value > 0;
+        case 'negative':
+            return typeof value === 'number' && value < 0;
+        case 'zero':
+            return value === 0;
+        case 'truthy':
+            return !!value;
+        case 'falsy':
+            return !value;
+        case 'primitive':
+            return value !== Object(value);
+        case 'reference':
+            return value === Object(value);
+        default:
+            return actualType === expectedType;
+    }
+};
+
+export const pickFields = (obj, keys) => {
+    if (!obj || typeof obj !== 'object') {
+        return {};
+    }
+
+    const result = {};
+
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+
+    return result;
+};
+
+export const omitFields = (obj, keys) => {
+    if (!obj || typeof obj !== 'object' || !Array.isArray(keys)) {
+        return {};
+    }
+
+    const result = {};
+
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key) && !keys.includes(key)) {
+            result[key] = obj[key];
+        }
+    }
+
+    return result;
+};
+
+export const isEmptyObject = (obj) => {
+    // 首先检查是否为对象
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+        return false;
+    }
+
+    // 检查是否为空对象
+    return Object.keys(obj).length === 0;
+};
+
+export const isEmptyArray = (arr) => {
+    // 首先检查是否为数组
+    if (!Array.isArray(arr)) {
+        return false;
+    }
+
+    // 检查是否为空数组
+    return arr.length === 0;
+};
+
+// 返回结果
+export const RYes = (msg = '', data = {}, other = {}) => {
+    return {
+        ...other,
+        code: 0,
+        msg: msg,
+        data: data
+    };
+};
+
+export const RNo = (msg = '', data = {}, other = {}) => {
+    return {
+        ...other,
+        code: 1,
+        msg: msg,
+        data: data
+    };
+};
+
+export const filename2 = (importMetaUrl) => {
+    return fileURLToPath(importMetaUrl);
+};
+
+export const dirname2 = (importMetaUrl) => {
+    return path.dirname(fileURLToPath(importMetaUrl));
+};

package/utils/validate.js

@@ -0,0 +1,244 @@
+import { ruleSplit, isType } from './util.js';
+
+/**
+ * 验证器类
+ */
+export class Validator {
+    /**
+     * 验证数据
+     * @param {Object} data - 要验证的数据对象
+     * @param {Object} rules - 验证规则对象
+     * @param {Array} required - 必传字段数组
+     * @returns {Object} { code: 0|1, fields: {} }
+     */
+    validate(data, rules, required = []) {
+        const result = {
+            code: 0,
+            fields: {}
+        };
+
+        // 参数检查
+        if (!this.checkParams(data, rules, required, result)) {
+            return result;
+        }
+
+        // 检查必传字段
+        this.checkRequiredFields(data, rules, required, result);
+
+        // 验证所有在规则中定义的字段
+        this.validateFields(data, rules, required, result);
+
+        return result;
+    }
+
+    /**
+     * 检查参数有效性
+     */
+    checkParams(data, rules, required, result) {
+        if (!data || typeof data !== 'object') {
+            result.code = 1;
+            result.fields.error = '数据必须是对象格式';
+            return false;
+        }
+
+        if (!rules || typeof rules !== 'object') {
+            result.code = 1;
+            result.fields.error = '验证规则必须是对象格式';
+            return false;
+        }
+
+        if (!Array.isArray(required)) {
+            result.code = 1;
+            result.fields.error = '必传字段必须是数组格式';
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * 检查必传字段
+     */
+    checkRequiredFields(data, rules, required, result) {
+        for (const fieldName of required) {
+            if (!(fieldName in data) || data[fieldName] === undefined || data[fieldName] === null || data[fieldName] === '') {
+                result.code = 1;
+                const ruleParts = rules[fieldName]?.split(',') || [];
+                const fieldLabel = ruleParts[0] || fieldName;
+                result.fields[fieldName] = `${fieldLabel}(${fieldName})为必填项`;
+            }
+        }
+    }
+
+    /**
+     * 验证所有字段
+     */
+    validateFields(data, rules, required, result) {
+        for (const [fieldName, rule] of Object.entries(rules)) {
+            // 如果字段不存在且不是必传字段，跳过验证
+            if (!(fieldName in data) && !required.includes(fieldName)) {
+                continue;
+            }
+
+            // 如果必传验证已经失败，跳过后续验证
+            if (result.fields[fieldName]) {
+                continue;
+            }
+
+            const value = data[fieldName];
+            const error = this.validateFieldValue(value, rule, fieldName);
+
+            if (error) {
+                result.code = 1;
+                result.fields[fieldName] = error;
+            }
+        }
+    }
+
+    /**
+     * 验证单个字段的值
+     */
+    validateFieldValue(value, rule, fieldName) {
+        const [name, type, minStr, maxStr, specStr] = ruleSplit(rule);
+        const min = minStr === 'null' ? null : parseInt(minStr) || 0;
+        const max = maxStr === 'null' ? null : parseInt(maxStr) || 0;
+        const spec = specStr === 'null' ? null : specStr.trim();
+
+        switch (type.toLowerCase()) {
+            case 'number':
+                return this.validateNumber(value, name, min, max, spec, fieldName);
+            case 'string':
+                return this.validateString(value, name, min, max, spec, fieldName);
+            case 'array':
+                return this.validateArray(value, name, min, max, spec, fieldName);
+            default:
+                return `字段 ${fieldName} 的类型 ${type} 不支持`;
+        }
+    }
+
+    /**
+     * 验证数字类型
+     */
+    validateNumber(value, name, min, max, spec, fieldName) {
+        try {
+            if (isType(value, 'number') === false) {
+                return `${name}(${fieldName})必须是数字`;
+            }
+
+            if (min !== null && value < min) {
+                return `${name}(${fieldName})不能小于${min}`;
+            }
+
+            if (min !== null && max > 0 && value > max) {
+                return `${name}(${fieldName})不能大于${max}`;
+            }
+
+            if (spec && spec.trim() !== '') {
+                return this.validateNumberExpression(value, name, spec, fieldName);
+            }
+
+            return null;
+        } catch (error) {
+            return `${name}(${fieldName})的计算规则格式错误: ${error.message}`;
+        }
+    }
+
+    /**
+     * 验证数字表达式
+     */
+    validateNumberExpression(value, name, spec, fieldName) {
+        const parts = spec.split('=');
+        if (parts.length !== 2) {
+            return `${name}(${fieldName})的计算规则必须包含等号`;
+        }
+
+        const leftExpression = parts[0].trim();
+        const rightValue = parseFloat(parts[1].trim());
+
+        if (isNaN(rightValue)) {
+            return `${name}(${fieldName})的计算规则右边必须是数字`;
+        }
+
+        const safePattern = /^[x\d\+\-\*\/\(\)\.\s]+$/;
+        if (!safePattern.test(leftExpression)) {
+            return `${name}(${fieldName})的表达式包含不安全的字符`;
+        }
+
+        let processedExpression = leftExpression.replace(/x/g, value.toString());
+        const leftResult = new Function('return ' + processedExpression)();
+
+        if (typeof leftResult !== 'number' || !isFinite(leftResult)) {
+            return `${name}(${fieldName})的表达式计算结果不是有效数字`;
+        }
+
+        if (Math.abs(leftResult - rightValue) > Number.EPSILON) {
+            return `${name}(${fieldName})不满足计算条件 ${spec}`;
+        }
+
+        return null;
+    }
+
+    /**
+     * 验证字符串类型
+     */
+    validateString(value, name, min, max, spec, fieldName) {
+        try {
+            if (isType(value, 'string') === false) {
+                return `${name}(${fieldName})必须是字符串`;
+            }
+
+            if (min !== null && value.length < min) {
+                return `${name}(${fieldName})长度不能少于${min}个字符`;
+            }
+
+            if (max !== null && max > 0 && value.length > max) {
+                return `${name}(${fieldName})长度不能超过${max}个字符`;
+            }
+
+            if (spec && spec.trim() !== '') {
+                const regExp = new RegExp(spec);
+                if (!regExp.test(value)) {
+                    return `${name}(${fieldName})格式不正确`;
+                }
+            }
+
+            return null;
+        } catch (error) {
+            return `${name}(${fieldName})的正则表达式格式错误`;
+        }
+    }
+
+    /**
+     * 验证数组类型
+     */
+    validateArray(value, name, min, max, spec, fieldName) {
+        try {
+            if (!Array.isArray(value)) {
+                return `${name}(${fieldName})必须是数组`;
+            }
+
+            if (min !== null && value.length < min) {
+                return `${name}(${fieldName})至少需要${min}个元素`;
+            }
+
+            if (max !== null && max > 0 && value.length > max) {
+                return `${name}(${fieldName})最多只能有${max}个元素`;
+            }
+
+            if (spec && spec.trim() !== '') {
+                const regExp = new RegExp(spec);
+                for (const item of value) {
+                    if (!regExp.test(String(item))) {
+                        return `${name}(${fieldName})中的元素"${item}"格式不正确`;
+                    }
+                }
+            }
+
+            return null;
+        } catch (error) {
+            return `${name}(${fieldName})的正则表达式格式错误: ${error.message}`;
+        }
+    }
+}
+
+export const validator = new Validator();