befly 0.1.26

package/schema/health.json

@@ -0,0 +1 @@
+{}

package/schema/tool.json

@@ -0,0 +1,6 @@
+{
+    "filename": "文件名,string,1,255,null",
+    "content": "内容,string,0,1000000,null",
+    "type": "类型,string,0,50,null",
+    "path": "路径,string,1,500,null"
+}

package/utils/api.js

@@ -0,0 +1,49 @@
+import { Logger } from '../utils/logger.js';
+import { RYes, RNo } from '../utils/util.js';
+export class Api {
+    // GET 方法
+    static GET(name, auth = false, fields = {}, required = [], handler) {
+        return {
+            method: 'GET',
+            name: name,
+            auth: auth,
+            fields: fields,
+            required: required,
+            handler: this.wrapHandler(handler)
+        };
+    }
+
+    // POST 方法
+    static POST(name, auth = false, fields = {}, required = [], handler) {
+        return {
+            method: 'POST',
+            name: name,
+            auth: auth,
+            fields: fields,
+            required: required,
+            handler: this.wrapHandler(handler)
+        };
+    }
+
+    // 包装处理器，自动处理异常和响应格式
+    static wrapHandler(handler) {
+        return async (bp, ctx, req) => {
+            try {
+                const result = await handler(bp, ctx, req);
+
+                return result;
+            } catch (error) {
+                Logger.error({
+                    msg: '内部服务器错误',
+                    error: error.message,
+                    stack: error.stack,
+                    url: req?.url || '',
+                    user: ctx?.user || {}
+                });
+
+                // 返回错误响应
+                return RNo('内部服务器错误');
+            }
+        };
+    }
+}

package/utils/colors.js

@@ -0,0 +1,83 @@
+const p = process || {},
+    argv = p.argv || [],
+    env = p.env || {};
+const isColorSupported = !(!!env.NO_COLOR || argv.includes('--no-color')) && (!!env.FORCE_COLOR || argv.includes('--color') || p.platform === 'win32' || ((p.stdout || {}).isTTY && env.TERM !== 'dumb') || !!env.CI);
+
+const formatter =
+    (open, close, replace = open) =>
+    (input) => {
+        let string = '' + input,
+            index = string.indexOf(close, open.length);
+        return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+
+const replaceClose = (string, close, replace, index) => {
+    let result = '',
+        cursor = 0;
+    do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+};
+
+const createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+        isColorSupported: enabled,
+        reset: f('\x1b[0m', '\x1b[0m'),
+        bold: f('\x1b[1m', '\x1b[22m', '\x1b[22m\x1b[1m'),
+        dim: f('\x1b[2m', '\x1b[22m', '\x1b[22m\x1b[2m'),
+        italic: f('\x1b[3m', '\x1b[23m'),
+        underline: f('\x1b[4m', '\x1b[24m'),
+        inverse: f('\x1b[7m', '\x1b[27m'),
+        hidden: f('\x1b[8m', '\x1b[28m'),
+        strikethrough: f('\x1b[9m', '\x1b[29m'),
+
+        black: f('\x1b[30m', '\x1b[39m'),
+        red: f('\x1b[31m', '\x1b[39m'),
+        green: f('\x1b[32m', '\x1b[39m'),
+        yellow: f('\x1b[33m', '\x1b[39m'),
+        blue: f('\x1b[34m', '\x1b[39m'),
+        magenta: f('\x1b[35m', '\x1b[39m'),
+        cyan: f('\x1b[36m', '\x1b[39m'),
+        white: f('\x1b[37m', '\x1b[39m'),
+        gray: f('\x1b[90m', '\x1b[39m'),
+
+        bgBlack: f('\x1b[40m', '\x1b[49m'),
+        bgRed: f('\x1b[41m', '\x1b[49m'),
+        bgGreen: f('\x1b[42m', '\x1b[49m'),
+        bgYellow: f('\x1b[43m', '\x1b[49m'),
+        bgBlue: f('\x1b[44m', '\x1b[49m'),
+        bgMagenta: f('\x1b[45m', '\x1b[49m'),
+        bgCyan: f('\x1b[46m', '\x1b[49m'),
+        bgWhite: f('\x1b[47m', '\x1b[49m'),
+
+        blackBright: f('\x1b[90m', '\x1b[39m'),
+        redBright: f('\x1b[91m', '\x1b[39m'),
+        greenBright: f('\x1b[92m', '\x1b[39m'),
+        yellowBright: f('\x1b[93m', '\x1b[39m'),
+        blueBright: f('\x1b[94m', '\x1b[39m'),
+        magentaBright: f('\x1b[95m', '\x1b[39m'),
+        cyanBright: f('\x1b[96m', '\x1b[39m'),
+        whiteBright: f('\x1b[97m', '\x1b[39m'),
+
+        bgBlackBright: f('\x1b[100m', '\x1b[49m'),
+        bgRedBright: f('\x1b[101m', '\x1b[49m'),
+        bgGreenBright: f('\x1b[102m', '\x1b[49m'),
+        bgYellowBright: f('\x1b[103m', '\x1b[49m'),
+        bgBlueBright: f('\x1b[104m', '\x1b[49m'),
+        bgMagentaBright: f('\x1b[105m', '\x1b[49m'),
+        bgCyanBright: f('\x1b[106m', '\x1b[49m'),
+        bgWhiteBright: f('\x1b[107m', '\x1b[49m')
+    };
+};
+
+const colors = createColors();
+colors.info = colors.blue('i');
+colors.success = colors.green('√');
+colors.warn = colors.yellow('‼');
+colors.error = colors.red('x');
+
+export { colors };

package/utils/crypto.js

@@ -0,0 +1,260 @@
+import { createSign } from 'node:crypto';
+
+export class Crypto2 {
+    /**
+     * MD5 哈希
+     * @param {string|Uint8Array} data - 要哈希的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} MD5 哈希值
+     */
+    static md5(data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher('md5');
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * HMAC-MD5 签名
+     * @param {string|Uint8Array} key - 密钥
+     * @param {string|Uint8Array} data - 要签名的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} HMAC-MD5 签名
+     */
+    static hmacMd5(key, data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher('md5', key);
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * SHA-1 哈希
+     * @param {string|Uint8Array} data - 要哈希的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} SHA-1 哈希值
+     */
+    static sha1(data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher('sha1');
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * HMAC-SHA1 签名
+     * @param {string|Uint8Array} key - 密钥
+     * @param {string|Uint8Array} data - 要签名的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} HMAC-SHA1 签名
+     */
+    static hmacSha1(key, data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher('sha1', key);
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * SHA-256 哈希
+     * @param {string|Uint8Array} data - 要哈希的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} SHA-256 哈希值
+     */
+    static sha256(data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher('sha256');
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    static rsaSha256(data, privateKey, encoding = 'hex') {
+        const sign = createSign('RSA-SHA256');
+        sign.update(data);
+        const signature = sign.sign(privateKey, encoding);
+        return signature;
+    }
+
+    /**
+     * HMAC-SHA256 签名
+     * @param {string|Uint8Array} key - 密钥
+     * @param {string|Uint8Array} data - 要签名的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} HMAC-SHA256 签名
+     */
+    static hmacSha256(key, data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher('sha256', key);
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * SHA-512 哈希
+     * @param {string|Uint8Array} data - 要哈希的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} SHA-512 哈希值
+     */
+    static sha512(data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher('sha512');
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * HMAC-SHA512 签名
+     * @param {string|Uint8Array} key - 密钥
+     * @param {string|Uint8Array} data - 要签名的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} HMAC-SHA512 签名
+     */
+    static hmacSha512(key, data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher('sha512', key);
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * 通用哈希方法
+     * @param {string} algorithm - 算法名称 ('md5', 'sha1', 'sha256', 'sha512')
+     * @param {string|Uint8Array} data - 要哈希的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} 哈希值
+     */
+    static hash(algorithm, data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher(algorithm);
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * 通用 HMAC 方法
+     * @param {string} algorithm - 算法名称 ('md5', 'sha1', 'sha256', 'sha512')
+     * @param {string|Uint8Array} key - 密钥
+     * @param {string|Uint8Array} data - 要签名的数据
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {string} HMAC 签名
+     */
+    static hmac(algorithm, key, data, encoding = 'hex') {
+        const hasher = new Bun.CryptoHasher(algorithm, key);
+        hasher.update(data);
+        return hasher.digest(encoding);
+    }
+
+    /**
+     * 文件哈希
+     * @param {string} filePath - 文件路径
+     * @param {string} algorithm - 算法名称 (默认 'sha256')
+     * @param {string} encoding - 输出编码 ('hex', 'base64')
+     * @returns {Promise<string>} 文件哈希值
+     */
+    static async hashFile(filePath, algorithm = 'sha256', encoding = 'hex') {
+        const file = Bun.file(filePath);
+        const hasher = new Bun.CryptoHasher(algorithm);
+
+        const stream = file.stream();
+        const reader = stream.getReader();
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                hasher.update(value);
+            }
+            return hasher.digest(encoding);
+        } finally {
+            reader.releaseLock();
+        }
+    }
+
+    /**
+     * 创建流式哈希器
+     * @param {string} algorithm - 算法名称
+     * @param {string|Uint8Array} key - 可选的 HMAC 密钥
+     * @returns {StreamHasher} 流式哈希器实例
+     */
+    static createHasher(algorithm, key = null) {
+        return new StreamHasher(algorithm, key);
+    }
+
+    /**
+     * 密码哈希 (使用 Argon2)
+     * @param {string} password - 密码
+     * @param {object} options - 选项
+     * @returns {Promise<string>} 哈希后的密码
+     */
+    static async hashPassword(password, options = {}) {
+        return await Bun.password.hash(password, options);
+    }
+
+    /**
+     * 验证密码
+     * @param {string} password - 原始密码
+     * @param {string} hash - 哈希值
+     * @returns {Promise<boolean>} 验证结果
+     */
+    static async verifyPassword(password, hash) {
+        return await Bun.password.verify(password, hash);
+    }
+
+    /**
+     * 快速哈希 (非密码学)
+     * @param {string|Uint8Array} data - 数据
+     * @param {number} seed - 种子值
+     * @returns {number} 64位哈希值
+     */
+    static fastHash(data, seed = 0) {
+        return Bun.hash(data, seed);
+    }
+}
+
+/**
+ * 流式哈希器类
+ */
+class StreamHasher {
+    constructor(algorithm, key = null) {
+        this.hasher = new Bun.CryptoHasher(algorithm, key);
+        this.finalized = false;
+    }
+
+    /**
+     * 更新数据
+     * @param {string|Uint8Array} data - 数据
+     * @returns {StreamHasher} 支持链式调用
+     */
+    update(data) {
+        if (this.finalized) {
+            throw new Error('哈希器已经完成，不能再更新数据');
+        }
+        this.hasher.update(data);
+        return this;
+    }
+
+    /**
+     * 生成最终哈希值
+     * @param {string} encoding - 输出编码
+     * @returns {string} 哈希值
+     */
+    digest(encoding = 'hex') {
+        if (this.finalized) {
+            throw new Error('哈希器已经完成');
+        }
+        this.finalized = true;
+        return this.hasher.digest(encoding);
+    }
+
+    /**
+     * 复制哈希器
+     * @returns {StreamHasher} 新的哈希器实例
+     */
+    copy() {
+        if (this.finalized) {
+            throw new Error('不能复制已完成的哈希器');
+        }
+        const newHasher = new StreamHasher();
+        newHasher.hasher = this.hasher.copy();
+        return newHasher;
+    }
+}
+
+// 使用示例：
+// const md5Hash = Crypto.md5('hello world');
+// const hmacMd5 = Crypto.hmacMd5('secret-key', 'hello world');
+// const sha256Hash = Crypto.sha256('hello world');
+// const fileHash = await Crypto.hashFile('./file.txt', 'md5');
+// const hasher = Crypto.createHasher('md5').update('hello').update(' world');
+// const result = hasher.digest('hex');

package/utils/curd.js

@@ -0,0 +1,183 @@
+import { omitFields } from './util.js';
+
+export class Crud {
+    constructor(db, redis, sql) {
+        this.db = db;
+        this.redis = redis;
+        this.sql = sql;
+        this.initMethods();
+    }
+
+    initMethods() {
+        // 将所有 CRUD 方法直接挂载到 db 实例上
+        this.db.insData = this.insData.bind(this);
+        this.db.updData = this.updData.bind(this);
+        this.db.delData = this.delData.bind(this);
+        this.db.getOne = this.getOne.bind(this);
+        this.db.getList = this.getList.bind(this);
+        this.db.getAll = this.getAll.bind(this);
+        this.db.getCount = this.getCount.bind(this);
+    }
+
+    // 事务方法
+    async trans(callback) {
+        return await this.db.transaction().execute(async (trx) => {
+            // 创建一个临时的 Crud 实例，使用事务连接
+            const transactionCrud = new Crud(trx, this.redis, this.sql);
+            return await callback(transactionCrud);
+        });
+    }
+
+    // 增强的插入方法 - 自动添加 ID 和时间戳，支持链式调用
+    insData(tableName, data) {
+        const insertQuery = this.db.insertInto(tableName);
+        const redis = this.redis;
+
+        insertQuery.exec = async function () {
+            const now = Date.now();
+            let processedData = data;
+
+            if (Array.isArray(data)) {
+                processedData = await Promise.all(
+                    data.map(async (item) => ({
+                        ...item,
+                        id: await redis.genTimeID(),
+                        created_at: now,
+                        updated_at: now
+                    }))
+                );
+            } else {
+                processedData = {
+                    ...data,
+                    id: await redis.genTimeID(),
+                    created_at: now,
+                    updated_at: now
+                };
+            }
+
+            const result = await this.values(processedData).execute();
+            return { data: result }; // 返回统一格式
+        };
+
+        return insertQuery;
+    }
+
+    // 增强的更新方法 - 自动添加 updated_at，支持链式调用
+    updData(tableName, data) {
+        const updateData = {
+            ...omitFields(data, ['id', 'created_at', 'deleted_at']),
+            updated_at: Date.now()
+        };
+
+        const updateQuery = this.db.updateTable(tableName).set(updateData);
+
+        updateQuery.exec = async function () {
+            const result = await this.execute();
+            return { data: result }; // 返回统一格式
+        };
+
+        return updateQuery;
+    }
+
+    // 增强的删除方法 - 支持链式调用
+    delData(tableName) {
+        const deleteQuery = this.db.deleteFrom(tableName);
+
+        deleteQuery.exec = async function () {
+            const result = await this.execute();
+            return { data: result }; // 返回统一格式
+        };
+
+        return deleteQuery;
+    }
+
+    // 查询单条记录 - 支持链式调用
+    getOne(tableName, fields) {
+        let selectQuery;
+
+        if (fields) {
+            selectQuery = Array.isArray(fields) ? this.db.selectFrom(tableName).select(fields) : this.db.selectFrom(tableName).select([fields]);
+        } else {
+            selectQuery = this.db.selectFrom(tableName).selectAll();
+        }
+
+        // 默认过滤软删除的数据
+        selectQuery = selectQuery.where('state', '<>', 2);
+
+        // 添加 exec 方法，自动返回单条记录
+        selectQuery.exec = async function () {
+            const result = await this.executeTakeFirst();
+            return { data: result }; // 返回统一格式
+        };
+
+        return selectQuery;
+    }
+
+    // 查询列表 - 支持链式调用和分页
+    getList(tableName, fields, page = 1, pageSize = 20) {
+        let selectQuery;
+
+        if (fields) {
+            selectQuery = Array.isArray(fields) ? this.db.selectFrom(tableName).select(fields) : this.db.selectFrom(tableName).select([fields]);
+        } else {
+            selectQuery = this.db.selectFrom(tableName).selectAll();
+        }
+
+        // 默认过滤软删除的数据
+        selectQuery = selectQuery.where('state', '<>', 2);
+
+        // 添加 exec 方法 - 支持分页，只返回数据列表
+        selectQuery.exec = async function () {
+            const offset = (page - 1) * pageSize;
+            const result = await this.limit(pageSize).offset(offset).execute();
+            return { data: result };
+        };
+
+        return selectQuery;
+    }
+
+    // 查询所有记录 - 支持链式调用
+    getAll(tableName, fields) {
+        let selectQuery;
+
+        if (fields) {
+            selectQuery = Array.isArray(fields) ? this.db.selectFrom(tableName).select(fields) : this.db.selectFrom(tableName).select([fields]);
+        } else {
+            selectQuery = this.db.selectFrom(tableName).selectAll();
+        }
+
+        // 默认过滤软删除的数据
+        selectQuery = selectQuery.where('state', '<>', 2);
+
+        // 添加 exec 方法，执行查询所有记录
+        selectQuery.exec = async function () {
+            const result = await this.execute();
+            return { data: result }; // 返回统一格式
+        };
+
+        return selectQuery;
+    }
+
+    // 便捷的计数方法 - 支持链式调用
+    getCount(tableName) {
+        const sql = this.sql;
+        const countQuery = this.db
+            .selectFrom(tableName)
+            .select(sql`count(*)`.as('total'))
+            .where('state', '<>', 2);
+
+        // 添加便捷的 exec 方法
+        countQuery.exec = async function () {
+            const result = await this.executeTakeFirst();
+            const count = Number(result?.total || 0);
+            return { data: count }; // 返回统一格式
+        };
+
+        return countQuery;
+    }
+
+    // 获取原始数据库实例
+    getDb() {
+        return this.db;
+    }
+}