befly 0.1.26

package/main.js

@@ -0,0 +1,410 @@
+import path from 'node:path';
+import { Env } from './config/env.js';
+
+// 工具函数
+import { Api } from './utils/api.js';
+import { Logger } from './utils/logger.js';
+import { Jwt } from './utils/jwt.js';
+import { validator } from './utils/validate.js';
+import { Crypto2 } from './utils/crypto.js';
+import { XMLParser } from './libs/xml/XMLParser.js';
+import { isEmptyObject, isType, pickFields, sortPlugins, RYes, RNo, filename2, dirname2 } from './utils/util.js';
+
+class BunPii {
+    constructor(options = {}) {
+        this.apiRoutes = new Map();
+        this.pluginLists = [];
+        this.appContext = {};
+        this.appOptions = options;
+    }
+
+    async initCheck() {
+        try {
+            const checksDir = path.join(dirname2(import.meta.url), 'checks');
+            const glob = new Bun.Glob('*.js');
+
+            // 统计信息
+            let totalChecks = 0;
+            let passedChecks = 0;
+            let failedChecks = 0;
+
+            // 扫描并执行检查函数
+            for await (const file of glob.scan({
+                cwd: checksDir,
+                onlyFiles: true,
+                absolute: true
+            })) {
+                const fileName = path.basename(file);
+                if (fileName.startsWith('_')) continue; // 跳过以下划线开头的文件
+
+                try {
+                    totalChecks++;
+
+                    // 导入检查模块
+                    const check = await import(file);
+
+                    // 执行默认导出的函数
+                    if (typeof check.default === 'function') {
+                        const checkResult = await check.default(this.appContext);
+                        if (checkResult === true) {
+                            passedChecks++;
+                        } else {
+                            Logger.error(`检查未通过: ${fileName}`);
+                            failedChecks++;
+                        }
+                    } else {
+                        Logger.warn(`文件 ${fileName} 未导出默认函数`);
+                        failedChecks++;
+                    }
+                } catch (error) {
+                    Logger.error({
+                        msg: `检查失败 ${fileName}`,
+                        error: error.message,
+                        stack: error.stack
+                    });
+                    failedChecks++;
+                }
+            }
+
+            // 输出检查结果统计
+            Logger.info(`总检查数: ${totalChecks}, 通过: ${passedChecks}, 失败: ${failedChecks}`);
+
+            if (failedChecks > 0) {
+                process.exit();
+            } else if (totalChecks > 0) {
+                Logger.info(`所有系统检查通过!`);
+            } else {
+                Logger.info(`未执行任何检查`);
+            }
+        } catch (error) {
+            Logger.error({
+                msg: '加载接口时发生错误',
+                error: error.message,
+                stack: error.stack
+            });
+            process.exit();
+        }
+    }
+
+    async loadPlugins() {
+        try {
+            const glob = new Bun.Glob('*.js');
+            const corePlugins = [];
+            const userPlugins = [];
+            const loadedPluginNames = new Set(); // 用于跟踪已加载的插件名称
+
+            // 扫描指定目录
+            for await (const file of glob.scan({
+                cwd: path.join(dirname2(import.meta.url), 'plugins'),
+                onlyFiles: true,
+                absolute: true
+            })) {
+                const fileName = path.basename(file, '.js');
+                if (fileName.startsWith('_')) continue;
+                const plugin = await import(file);
+                const pluginInstance = plugin.default;
+                pluginInstance.pluginName = fileName;
+                corePlugins.push(pluginInstance);
+                loadedPluginNames.add(fileName); // 记录已加载的核心插件名称
+            }
+
+            const sortedCorePlugins = sortPlugins(corePlugins);
+            if (sortedCorePlugins === false) {
+                Logger.error(`插件依赖关系错误，请检查插件的 after 属性`);
+                process.exit();
+            }
+
+            for (const plugin of sortedCorePlugins) {
+                try {
+                    this.pluginLists.push(plugin);
+                    this.appContext[plugin.pluginName] = typeof plugin?.onInit === 'function' ? await plugin?.onInit(this.appContext) : {};
+                } catch (error) {
+                    Logger.warn(`插件 ${plugin.pluginName} 初始化失败:`, error.message);
+                }
+            }
+
+            // 扫描指定目录
+            for await (const file of glob.scan({
+                cwd: path.join(process.cwd(), 'plugins'),
+                onlyFiles: true,
+                absolute: true
+            })) {
+                const fileName = path.basename(file, '.js');
+                if (fileName.startsWith('_')) continue;
+
+                // 检查是否已经加载了同名的核心插件
+                if (loadedPluginNames.has(fileName)) {
+                    Logger.info(`跳过用户插件 ${fileName}，因为同名的核心插件已存在`);
+                    continue;
+                }
+
+                const plugin = await import(file);
+                const pluginInstance = plugin.default;
+                pluginInstance.pluginName = fileName;
+                userPlugins.push(pluginInstance);
+            }
+
+            const sortedUserPlugins = sortPlugins(userPlugins);
+            if (sortedUserPlugins === false) {
+                Logger.error(`插件依赖关系错误，请检查插件的 after 属性`);
+                process.exit();
+            }
+
+            for (const plugin of sortedUserPlugins) {
+                try {
+                    this.pluginLists.push(plugin);
+                    this.appContext[plugin.pluginName] = typeof plugin?.onInit === 'function' ? await plugin?.onInit(this.appContext) : {};
+                } catch (error) {
+                    Logger.warn(`插件 ${plugin.pluginName} 初始化失败:`, error.message);
+                }
+            }
+        } catch (error) {
+            Logger.error({
+                msg: '加载插件时发生错误',
+                error: error.message,
+                stack: error.stack
+            });
+        }
+    }
+    async loadApis(dirName) {
+        try {
+            const coreApisDir = path.join(dirname2(import.meta.url), 'apis');
+            const userApisDir = path.join(process.cwd(), 'apis');
+            const glob = new Bun.Glob('**/*.js');
+            const apiDir = dirName === 'core' ? coreApisDir : userApisDir;
+            // 扫描指定目录
+            for await (const file of glob.scan({
+                cwd: apiDir,
+                onlyFiles: true,
+                absolute: true
+            })) {
+                const fileName = path.basename(file, '.js');
+                const apiPath = path.relative(apiDir, file).replace(/\.js$/, '').replace(/\\/g, '/');
+                if (apiPath.indexOf('_') !== -1) continue;
+                const api = await import(file);
+                const apiInstance = api.default;
+                if (isType(api.name, 'string') === false || api.name.trim() === '') {
+                    throw new Error(`接口 ${apiPath} 的 name 属性必须是非空字符串`);
+                }
+                if (api.auth !== false && api.auth !== true && Array.isArray(api.auth) === false) {
+                    throw new Error(`接口 ${apiPath} 的 auth 属性必须是布尔值或字符串数组`);
+                }
+                if (isType(api.fields, 'object') === false) {
+                    throw new Error(`接口 ${apiPath} 的 fields 属性必须是对象`);
+                }
+                if (isType(api.required, 'array') === false) {
+                    throw new Error(`接口 ${apiPath} 的 required 属性必须是数组`);
+                }
+                // 数组的每一项都必须是字符串
+                if (api.required.some((item) => isType(item, 'string') === false)) {
+                    throw new Error(`接口 ${apiPath} 的 required 属性必须是字符串数组`);
+                }
+                if (isType(api.handler, 'function') === false) {
+                    throw new Error(`接口 ${apiPath} 的 handler 属性必须是函数`);
+                }
+                apiInstance.route = `${apiInstance.method.toUpperCase()}/api/${dirName}/${apiPath}`;
+                this.apiRoutes.set(apiInstance.route, apiInstance);
+            }
+        } catch (error) {
+            Logger.error({
+                msg: '加载接口时发生错误',
+                error: error.message,
+                stack: error.stack
+            });
+        }
+    }
+
+    /**
+     * 启动服务器
+     */
+    async listen(callback) {
+        await this.initCheck();
+        await this.loadPlugins();
+        await this.loadApis('core');
+        await this.loadApis('app');
+
+        const server = Bun.serve({
+            port: Env.APP_PORT,
+            hostname: Env.APP_HOST,
+            routes: {
+                '/': async (req) => {
+                    return Response.json({
+                        code: 0,
+                        msg: 'BunPii 接口服务已启动',
+                        data: {
+                            mode: Env.NODE_ENV
+                        }
+                    });
+                },
+                '/api/*': async (req) => {
+                    try {
+                        // 直接返回options请求
+                        if (req.method === 'OPTIONS') {
+                            return new Response();
+                        }
+                        // 初始化请求数据存储
+                        const ctx = {
+                            headers: Object.fromEntries(req.headers.entries()),
+                            body: {},
+                            user: {}
+                        };
+
+                        // 接口处理
+                        const url = new URL(req.url);
+                        const apiPath = `${req.method}${url.pathname}`;
+
+                        const api = this.apiRoutes.get(apiPath);
+
+                        // 接口不存在
+                        if (!api) return Response.json(RNo('接口不存在'));
+
+                        const authHeader = req.headers.get('authorization');
+                        if (authHeader && authHeader.startsWith('Bearer ')) {
+                            const token = authHeader.substring(7);
+
+                            try {
+                                const payload = await Jwt.verify(token);
+                                ctx.user = payload;
+                            } catch (error) {
+                                ctx.user = {};
+                            }
+                        } else {
+                            ctx.user = {};
+                        }
+                        // 配置参数
+                        if (req.method === 'GET') {
+                            if (isEmptyObject(api.fields) === false) {
+                                ctx.body = pickFields(Object.fromEntries(url.searchParams), Object.keys(api.fields));
+                            } else {
+                                ctx.body = Object.fromEntries(url.searchParams);
+                            }
+                        }
+                        if (req.method === 'POST') {
+                            try {
+                                const contentType = req.headers.get('content-type') || '';
+
+                                if (contentType.indexOf('json') !== -1) {
+                                    ctx.body = await req.json();
+                                } else if (contentType.indexOf('xml') !== -1) {
+                                    const textData = await req.text();
+                                    const xmlData = new XMLParser().parse(textData);
+                                    ctx.body = xmlData?.xml ? xmlData.xml : xmlData;
+                                } else if (contentType.indexOf('form-data') !== -1) {
+                                    ctx.body = await req.formData();
+                                } else if (contentType.indexOf('x-www-form-urlencoded') !== -1) {
+                                    const text = await clonedReq.text();
+                                    const formData = new URLSearchParams(text);
+                                    ctx.body = Object.fromEntries(formData);
+                                } else {
+                                    ctx.body = {};
+                                }
+                                if (isEmptyObject(api.fields) === false) {
+                                    ctx.body = pickFields(ctx.body, Object.keys(api.fields));
+                                }
+                            } catch (err) {
+                                Logger.error({
+                                    msg: '处理请求参数时发生错误',
+                                    error: err.message,
+                                    stack: err.stack
+                                });
+
+                                return Response.json(RNo('无效的请求参数格式'));
+                            }
+                        }
+
+                        // 插件钩子
+                        for await (const plugin of this.pluginLists) {
+                            try {
+                                if (typeof plugin?.onGet === 'function') {
+                                    await plugin?.onGet(this.appContext, ctx, req);
+                                }
+                            } catch (error) {
+                                Logger.error({
+                                    msg: '插件处理请求时发生错误',
+                                    error: error.message,
+                                    stack: error.stack
+                                });
+                            }
+                        }
+
+                        // 请求记录
+                        Logger.debug({
+                            msg: '通用接口日志',
+                            请求路径: apiPath,
+                            请求方法: req.method,
+                            用户信息: ctx.user,
+                            请求体: ctx.body
+                        });
+
+                        // 登录验证 auth 有3种值 分别为 true、false、['admin', 'user']
+                        if (api.auth === true && !ctx.user.id) {
+                            return Response.json(RNo('未登录'));
+                        }
+
+                        if (api.auth && api.auth !== true && ctx.user.role !== api.auth) {
+                            return Response.json(RNo('没有权限'));
+                        }
+
+                        // 参数验证
+                        const validate = validator.validate(ctx.body, api.fields, api.required);
+                        if (validate.code !== 0) {
+                            return Response.json(RNo('无效的请求参数格式', validate.fields));
+                        }
+
+                        // 执行函数
+                        const result = await api.handler(this.appContext, ctx, req);
+
+                        // 返回数据
+                        if (result && typeof result === 'object' && 'code' in result) {
+                            return Response.json(result);
+                        } else {
+                            return new Response(result);
+                        }
+                    } catch (error) {
+                        Logger.error({
+                            msg: '处理接口请求时发生错误',
+                            error: error.message,
+                            stack: error.stack,
+                            url: req.url
+                        });
+                        return Response.json(RNo('内部服务器错误'));
+                    }
+                },
+                '/*': async (req) => {
+                    const url = new URL(req.url);
+                    const filePath = path.join(process.cwd(), 'public', url.pathname);
+
+                    try {
+                        const file = await Bun.file(filePath);
+                        if (await file.exists()) {
+                            return new Response(file, {
+                                headers: {
+                                    'Content-Type': file.type || 'application/octet-stream'
+                                }
+                            });
+                        } else {
+                            return Response.json(RNo('文件未找到'));
+                        }
+                    } catch (error) {
+                        return Response.json(RNo('文件读取失败'));
+                    }
+                },
+                ...(this.appOptions.routes || {})
+            },
+            error(error) {
+                Logger.error({
+                    msg: '服务启动时发生错误',
+                    error: error.message,
+                    stack: error.stack
+                });
+                return Response.json(RNo('内部服务器错误'));
+            }
+        });
+
+        if (callback && typeof callback === 'function') {
+            callback(server);
+        }
+    }
+}
+
+export { BunPii, Env, Api, Jwt, Crypto2, Logger, RYes, RNo };

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "befly",
+    "version": "0.1.26",
+    "description": "Buma - 为 Bun 专属打造的 API 接口框架核心引擎",
+    "type": "module",
+    "private": false,
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org"
+    },
+    "main": "main.js",
+    "exports": {
+        ".": "./main.js"
+    },
+    "scripts": {
+        "r": "bun publish --registry=https://registry.npmjs.org --access=public"
+    },
+    "keywords": [
+        "bun",
+        "api",
+        "framework",
+        "core",
+        "javascript",
+        "backend",
+        "rest",
+        "http"
+    ],
+    "author": "chensuiyi <bimostyle@qq.com>",
+    "homepage": "https://chensuiyi.me",
+    "license": "Apache-2.0",
+    "files": [
+        "apis/",
+        "checks/",
+        "config/",
+        "libs/",
+        "plugins/",
+        "schema/",
+        "utils/",
+        ".gitignore",
+        ".npmignore",
+        ".bunignore",
+        ".editorconfig",
+        ".npmrc",
+        ".prettierignore",
+        ".prettierrc",
+        "LICENSE",
+        "main.js",
+        "package.json",
+        "README.md",
+        "vitest.config.js"
+    ],
+    "gitHead": "763f398127df3dc2471295745b8dfde3fdd84a92"
+}

package/plugins/cors.js

@@ -0,0 +1,15 @@
+export default {
+    after: ['_redis', '_db'],
+    async onGet(bunpii, ctx, req) {
+        // 设置 CORS 头部
+        req.headers.set('Access-Control-Allow-Origin', req.headers.get('origin'));
+        req.headers.set('Access-Control-Allow-Methods', 'POST,GET,OPTIONS');
+        req.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        req.headers.set('Access-Control-Allow-Credentials', 'true');
+
+        // 处理预检请求
+        if (req.method === 'OPTIONS') {
+            req.status = 204;
+        }
+    }
+};

package/plugins/db.js

@@ -0,0 +1,56 @@
+import { Env } from '../config/env.js';
+import { Logger } from '../utils/logger.js';
+import { Crud } from '../utils/curd.js';
+
+export default {
+    after: ['_redis'],
+    async onInit(bunpii) {
+        try {
+            if (Env.MYSQL_ENABLE === 1) {
+                // 创建 MySQL 连接池
+                const config = {
+                    host: Env.MYSQL_HOST || '127.0.0.1',
+                    port: Env.MYSQL_PORT || 3306,
+                    database: Env.MYSQL_DB || 'test',
+                    user: Env.MYSQL_USER || 'root',
+                    password: Env.MYSQL_PASSWORD || 'root',
+                    connectionLimit: Env.MYSQL_POOL_MAX || 10,
+                    charset: 'utf8mb4_general_ci',
+                    // timezone: Env.TIMEZONE,
+                    debug: Env.MYSQL_DEBUG === 1
+                };
+
+                const createPool = await import('mysql2').then((m) => m.createPool);
+                const { Kysely, MysqlDialect, sql } = await import('kysely');
+
+                const pool = await createPool(config);
+
+                // 创建 Kysely 实例
+                const db = new Kysely({
+                    dialect: new MysqlDialect({
+                        pool: pool
+                    })
+                });
+
+                // 测试数据库连接
+                const result = await sql`SELECT VERSION() AS version`.execute(db);
+                if (result?.rows?.[0]?.version) {
+                    // 扩展数据库实例
+                    return new Crud(db, bunpii.redis, sql);
+                } else {
+                    return {};
+                }
+            } else {
+                Logger.warn(`Mysql 未启用，跳过初始化`);
+                return {};
+            }
+        } catch (error) {
+            Logger.error({
+                msg: '数据库连接失败',
+                message: error.message,
+                stack: error.stack
+            });
+            process.exit();
+        }
+    }
+};

package/plugins/logger.js

@@ -0,0 +1,13 @@
+import { Env } from '../config/env.js';
+import { Logger } from '../utils/logger.js';
+
+export default {
+    after: [],
+    async onInit(bunpii) {
+        try {
+            return Logger;
+        } catch (error) {
+            process.exit();
+        }
+    }
+};

package/plugins/redis.js

@@ -0,0 +1,116 @@
+import { Env } from '../config/env.js';
+import { Logger } from '../utils/logger.js';
+
+export default {
+    after: ['_logger'],
+    async onInit(bunpii) {
+        try {
+            if (Env.REDIS_ENABLE === 1) {
+                const config = {
+                    username: Env.REDIS_USERNAME || '',
+                    password: Env.REDIS_PASSWORD || '',
+                    database: Env.REDIS_DB || 0,
+                    socket: {
+                        host: Env.REDIS_HOST || '127.0.0.1',
+                        port: Env.REDIS_PORT || 6379,
+                        reconnectStrategy: (retries) => {
+                            // 指数退避重连策略，最大延迟 2 秒
+                            const jitter = Math.floor(Math.random() * 200);
+                            const delay = Math.min(Math.pow(2, retries) * 50, 2000);
+                            return delay + jitter;
+                        }
+                    }
+                };
+                const createClient = await import('@redis/client').then((m) => m.createClient);
+                const redis = createClient(config);
+
+                // 测试连接
+                try {
+                    await redis.connect();
+                    // 测试连接
+                    const result = await redis.ping();
+                } catch (error) {
+                    Logger.error({
+                        msg: 'Redis 连接失败',
+                        message: error.message,
+                        stack: error.stack
+                    });
+                    process.exit();
+                }
+
+                // 添加对象存储辅助方法
+                redis.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
+                        });
+                    }
+                };
+
+                redis.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;
+                    }
+                };
+
+                redis.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生成函数
+                redis.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}`);
+                };
+
+                return redis;
+            } else {
+                Logger.warn(`Redis 未启用，跳过初始化`);
+                return {};
+            }
+        } catch (err) {
+            Logger.error({
+                msg: 'Redis 初始化失败',
+                message: err.message,
+                stack: err.stack
+            });
+            process.exit();
+        }
+    }
+};

package/schema/common.json

@@ -0,0 +1,17 @@
+{
+    "id": "ID,number,1,999999999,x%2=0",
+    "email": "邮箱,string,5,100,^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
+    "phone": "手机号,string,11,11,^1[3-9]\\d{9}$",
+    "page": "页码,number,1,9999,null",
+    "limit": "每页数量,number,1,100,null",
+    "title": "标题,string,1,200,null",
+    "description": "描述,string,0,500,null",
+    "keyword": "关键词,string,1,50,null",
+    "status": "状态,string,1,20,null",
+    "enabled": "启用状态,number,0,1,null",
+    "date": "日期,string,10,10,^\\d{4}-\\d{2}-\\d{2}$",
+    "datetime": "日期时间,string,19,25,^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}",
+    "filename": "文件名,string,1,255,null",
+    "url": "网址,string,5,500,^https?://",
+    "tag": "标签,array,0,10,null"
+}

package/schema/debug.json

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