befly 3.8.1 → 3.8.2

package/lib/validator.ts

@@ -1,10 +1,9 @@
 /**
  * 数据验证器 - Befly 项目专用
- * 内置 RegexAliases，直接使用 util.ts 中的 parseRule
+ * 内置 RegexAliases，支持对象格式的字段定义
  */
 
-import { parseRule } from '../util.js';
-import type { TableDefinition, FieldRule } from '../types/common.js';
+import type { TableDefinition, FieldDefinition } from '../types/common.js';
 import type { ValidationResult, ValidationError } from '../types/validator';
 
 /**
@@ -106,7 +105,7 @@ export class Validator {
      * 检查参数有效性
      */
     private checkParams(data: any, rules: any, required: any, result: ValidationResult): boolean {
-        if (!data || typeof data !== 'object') {
+        if (!data || typeof data !== 'object' || Array.isArray(data)) {
             result.code = 1;
             result.fields.error = '数据必须是对象格式';
             return false;
@@ -135,8 +134,8 @@ export class Validator {
             const value = data[fieldName];
             if (!(fieldName in data) || value === undefined || value === null || value === '') {
                 result.code = 1;
-                const ruleParts = parseRule(rules[fieldName] || '');
-                const fieldLabel = ruleParts.name || fieldName;
+                const fieldDef = rules[fieldName];
+                const fieldLabel = fieldDef?.name || fieldName;
                 result.fields[fieldName] = `${fieldLabel}(${fieldName})为必填项`;
             }
         }
@@ -158,7 +157,7 @@ export class Validator {
             }
 
             const value = data[fieldName];
-            const error = this.validateFieldValue(value, rule, fieldName);
+            const error = this.validateFieldValue(value, rules[fieldName], fieldName);
 
             if (error) {
                 result.code = 1;
@@ -190,21 +189,20 @@ export class Validator {
     /**
      * 验证单个字段的值
      */
-    private validateFieldValue(value: any, rule: FieldRule, fieldName: string): ValidationError {
-        const parsed = parseRule(rule);
-        let { name, type, min, max, regex } = parsed;
+    private validateFieldValue(value: any, fieldDef: FieldDefinition, fieldName: string): ValidationError {
+        let { name, type, min, max, regexp } = fieldDef;
 
-        regex = this.resolveRegexAlias(regex);
+        regexp = this.resolveRegexAlias(regexp);
 
         switch (type.toLowerCase()) {
             case 'number':
-                return this.validateNumber(value, name, min, max, regex, fieldName);
+                return this.validateNumber(value, name, min, max, regexp, fieldName);
             case 'string':
             case 'text':
-                return this.validateString(value, name, min, max, regex, fieldName);
+                return this.validateString(value, name, min, max, regexp, fieldName);
             case 'array_string':
             case 'array_text':
-                return this.validateArray(value, name, min, max, regex, fieldName);
+                return this.validateArray(value, name, min, max, regexp, fieldName);
             default:
                 return `字段 ${fieldName} 的类型 ${type} 不支持`;
         }
@@ -215,7 +213,7 @@ export class Validator {
      */
     private validateNumber(value: any, name: string, min: number | null, max: number | null, spec: string | null, fieldName: string): ValidationError {
         try {
-            if (typeof value !== 'number' || Number.isNaN(value)) {
+            if (typeof value !== 'number' || Number.isNaN(value) || !isFinite(value)) {
                 return `${name}(${fieldName})必须是数字`;
             }
 
@@ -315,17 +313,16 @@ export class Validator {
     }
 
     /**
-     * 验证单个值
+     * 验证单个值（支持对象格式字段定义）
      */
-    validateSingleValue(value: any, rule: string): { valid: boolean; value: any; errors: string[] } {
-        const parsed = parseRule(rule);
-        let { name, type, min, max, regex, default: defaultValue } = parsed;
+    validateSingleValue(value: any, fieldDef: FieldDefinition): { valid: boolean; value: any; errors: string[] } {
+        let { name, type, min, max, regexp, default: defaultValue } = fieldDef;
 
-        regex = this.resolveRegexAlias(regex);
+        regexp = this.resolveRegexAlias(regexp);
 
         // 处理 undefined/null 值，使用默认值
         if (value === undefined || value === null) {
-            if (defaultValue !== 'null' && defaultValue !== null) {
+            if (defaultValue !== null) {
                 if ((type === 'array_string' || type === 'array_text') && typeof defaultValue === 'string') {
                     if (defaultValue === '[]') {
                         return { valid: true, value: [], errors: [] };
@@ -381,9 +378,9 @@ export class Validator {
                 if (max !== null && max > 0 && convertedValue > max) {
                     errors.push(`${name || '值'}不能大于${max}`);
                 }
-                if (regex && regex.trim() !== '' && regex !== 'null') {
+                if (regexp && regexp.trim() !== '') {
                     try {
-                        const regExp = new RegExp(regex);
+                        const regExp = new RegExp(regexp);
                         if (!regExp.test(String(convertedValue))) {
                             errors.push(`${name || '值'}格式不正确`);
                         }
@@ -404,9 +401,9 @@ export class Validator {
                 if (max !== null && max > 0 && convertedValue.length > max) {
                     errors.push(`${name || '值'}长度不能超过${max}个字符`);
                 }
-                if (regex && regex.trim() !== '' && regex !== 'null') {
+                if (regexp && regexp.trim() !== '') {
                     try {
-                        const regExp = new RegExp(regex);
+                        const regExp = new RegExp(regexp);
                         if (!regExp.test(convertedValue)) {
                             errors.push(`${name || '值'}格式不正确`);
                         }
@@ -427,9 +424,9 @@ export class Validator {
                 if (max !== null && max > 0 && convertedValue.length > max) {
                     errors.push(`${name || '值'}元素数量不能超过${max}个`);
                 }
-                if (regex && regex.trim() !== '' && regex !== 'null') {
+                if (regexp && regexp.trim() !== '') {
                     try {
-                        const regExp = new RegExp(regex);
+                        const regExp = new RegExp(regexp);
                         for (const item of convertedValue) {
                             if (!regExp.test(String(item))) {
                                 errors.push(`${name || '值'}的元素格式不正确`);
@@ -454,15 +451,15 @@ export class Validator {
      * 静态方法：快速验证
      */
     static validate(data: Record<string, any>, rules: TableDefinition, required?: string[]): ValidationResult;
-    static validate(value: any, rule: string): { valid: boolean; value: any; errors: string[] };
-    static validate(dataOrValue: any, rulesOrRule: any, required?: string[]): any {
+    static validate(value: any, fieldDef: FieldDefinition): { valid: boolean; value: any; errors: string[] };
+    static validate(dataOrValue: any, rulesOrFieldDef: any, required?: string[]): any {
         const validator = new Validator();
 
-        if (typeof rulesOrRule === 'string') {
-            return validator.validateSingleValue(dataOrValue, rulesOrRule);
+        if (rulesOrFieldDef && 'type' in rulesOrFieldDef) {
+            return validator.validateSingleValue(dataOrValue, rulesOrFieldDef);
         }
 
-        return validator.validate(dataOrValue, rulesOrRule, required || []);
+        return validator.validate(dataOrValue, rulesOrFieldDef, required || []);
     }
 
     /**

package/lifecycle/bootstrap.ts

@@ -4,7 +4,7 @@
  */
 
 import { Logger } from '../lib/logger.js';
-import { calcPerfTime, No } from '../util.js';
+import { calcPerfTime } from '../util.js';
 import { Env } from '../env.js';
 import { rootHandler } from '../router/root.js';
 import { apiHandler } from '../router/api.js';
@@ -21,18 +21,9 @@ import type { Plugin } from '../types/plugin.js';
 export class Bootstrap {
     /**
      * 启动HTTP服务器
-     * @param befly - Befly实例（需要访问 apiRoutes, pluginLists, appContext, appOptions）
-     * @param callback - 启动后的回调函数
+     * @param befly - Befly实例（需要访问 apiRoutes, pluginLists, appContext）
      */
-    static async start(
-        befly: {
-            apiRoutes: Map<string, ApiRoute>;
-            pluginLists: Plugin[];
-            appContext: BeflyContext;
-            appOptions: any;
-        },
-        callback?: (server: Server) => void
-    ): Promise<Server> {
+    static async start(befly: { apiRoutes: Map<string, ApiRoute>; pluginLists: Plugin[]; appContext: BeflyContext }): Promise<Server> {
         const startTime = Bun.nanoseconds();
 
         const server = Bun.serve({
@@ -41,12 +32,11 @@ export class Bootstrap {
             routes: {
                 '/': rootHandler,
                 '/api/*': apiHandler(befly.apiRoutes, befly.pluginLists, befly.appContext),
-                '/*': staticHandler,
-                ...(befly.appOptions.routes || {})
+                '/*': staticHandler
             },
             error: (error: Error) => {
                 Logger.error('服务启动时发生错误', error);
-                return Response.json(No('内部服务器错误'));
+                return Response.json({ code: 1, msg: '内部服务器错误' });
             }
         });
 
@@ -54,10 +44,6 @@ export class Bootstrap {
         Logger.info(`${Env.APP_NAME} 服务器启动成功! 服务器启动耗时: ${finalStartupTime}`);
         Logger.info(`服务器监听地址: http://${Env.APP_HOST}:${Env.APP_PORT}`);
 
-        if (callback && typeof callback === 'function') {
-            callback(server);
-        }
-
         return server;
     }
 }

package/lifecycle/lifecycle.ts

@@ -5,7 +5,8 @@
 
 import { Logger } from '../lib/logger.js';
 import { Database } from '../lib/database.js';
-import { Loader } from './loader.js';
+import { loadPlugins } from './loadPlugins.js';
+import { loadApis } from './loadApis.js';
 import { Checker } from './checker.js';
 import { Env } from '../env.js';
 import { calcPerfTime } from '../util.js';
@@ -15,7 +16,7 @@ import { Bootstrap } from './bootstrap.js';
 import type { Server } from 'bun';
 import type { Plugin } from '../types/plugin.js';
 import type { ApiRoute } from '../types/api.js';
-import type { BeflyContext, BeflyOptions } from '../types/befly.js';
+import type { BeflyContext } from '../types/befly.js';
 
 /**
  * 生命周期管理类
@@ -27,78 +28,34 @@ export class Lifecycle {
     /** 插件列表 */
     private pluginLists: Plugin[] = [];
 
-    /** 应用配置选项 */
-    private options: BeflyOptions;
-
-    constructor(options: BeflyOptions = {}) {
-        this.options = options;
-    }
+    constructor() {}
 
     /**
      * 启动完整的生命周期流程
      * @param appContext - 应用上下文
-     * @param callback - 启动完成后的回调函数
      */
-    async start(appContext: BeflyContext, callback?: (server: Server) => void): Promise<Server> {
+    async start(appContext: BeflyContext): Promise<Server> {
         const serverStartTime = Bun.nanoseconds();
 
         // 1. 执行系统检查
         await Checker.run();
 
         // 2. 加载插件
-        await Loader.loadPlugins({ pluginLists: this.pluginLists, appContext });
+        await loadPlugins({
+            pluginLists: this.pluginLists,
+            appContext: appContext
+        });
 
-        // 3. 加载所有 API（addon + app）
-        await this.loadAllApis();
+        // // 3. 加载所有 API
+        await loadApis(this.apiRoutes);
 
         // 4. 启动 HTTP 服务器
         const totalStartupTime = calcPerfTime(serverStartTime);
 
-        return await Bootstrap.start(
-            {
-                apiRoutes: this.apiRoutes,
-                pluginLists: this.pluginLists,
-                appContext,
-                appOptions: this.options
-            },
-            callback
-        );
-    }
-
-    /**
-     * 加载所有 API 路由
-     * 包括 core APIs、addon APIs 和 app APIs
-     */
-    private async loadAllApis(): Promise<void> {
-        // 1. 加载 Core APIs
-        try {
-            await Loader.loadApis('core', this.apiRoutes, { where: 'core' });
-        } catch (error: any) {
-            Logger.error(`核心 APIs 加载失败`, error);
-            throw error;
-        }
-
-        // 2. 加载 addon APIs
-        const addons = Addon.scan();
-
-        for (const addon of addons) {
-            const hasApis = Addon.dirExists(addon, 'apis');
-            if (hasApis) {
-                try {
-                    await Loader.loadApis(addon, this.apiRoutes, { where: 'addon', addonName: addon });
-                } catch (error: any) {
-                    Logger.error(`[组件 ${addon}] APIs 加载失败`, error);
-                    throw error;
-                }
-            }
-        }
-
-        // 3. 加载用户 APIs
-        try {
-            await Loader.loadApis('app', this.apiRoutes, { where: 'app' });
-        } catch (error: any) {
-            Logger.error(`用户 APIs 加载失败`, error);
-            throw error;
-        }
+        return await Bootstrap.start({
+            apiRoutes: this.apiRoutes,
+            pluginLists: this.pluginLists,
+            appContext: appContext
+        });
     }
 }

package/lifecycle/loadApis.ts

@@ -0,0 +1,164 @@
+/**
+ * API 加载器
+ * 负责扫描和加载所有 API 路由（核心、组件、用户）
+ */
+
+import { relative, basename } from 'pathe';
+import { existsSync } from 'node:fs';
+import { isPlainObject } from 'es-toolkit/compat';
+import { Logger } from '../lib/logger.js';
+import { calcPerfTime } from '../util.js';
+import { coreApiDir, projectApiDir } from '../paths.js';
+import { Addon } from '../lib/addon.js';
+import type { ApiRoute } from '../types/api.js';
+
+/**
+ * API 默认字段定义
+ * 这些字段会自动合并到所有 API 的 fields 中
+ * API 自定义的同名字段可以覆盖这些默认值
+ */
+const DEFAULT_API_FIELDS = {
+    id: {
+        name: 'ID',
+        type: 'number',
+        min: 1,
+        max: null
+    },
+    page: {
+        name: '页码',
+        type: 'number',
+        min: 1,
+        max: 9999
+    },
+    limit: {
+        name: '每页数量',
+        type: 'number',
+        min: 1,
+        max: 100
+    },
+    keyword: {
+        name: '关键词',
+        type: 'string',
+        min: 1,
+        max: 50
+    },
+    state: {
+        name: '状态',
+        type: 'number',
+        min: 0,
+        max: 2
+    }
+} as const;
+
+/**
+ * 扫描单个目录的 API 文件
+ * @param apiDir - API 目录路径
+ * @param apiRoutes - API 路由映射表
+ * @param routePrefix - 路由前缀（如 'core', 'addon/admin', ''）
+ * @param displayName - 显示名称（用于日志）
+ */
+async function scanApisFromDir(apiDir: string, apiRoutes: Map<string, ApiRoute>, routePrefix: string, displayName: string): Promise<void> {
+    if (!existsSync(apiDir)) {
+        return;
+    }
+
+    const glob = new Bun.Glob('**/*.ts');
+
+    for await (const file of glob.scan({
+        cwd: apiDir,
+        onlyFiles: true,
+        absolute: true
+    })) {
+        const fileName = basename(file).replace(/\.ts$/, '');
+        const apiPath = relative(apiDir, file).replace(/\.ts$/, '');
+        if (apiPath.indexOf('_') !== -1) continue;
+
+        try {
+            const apiImport = await import(file);
+            const api = apiImport.default;
+            // 验证必填属性：name 和 handler
+            if (typeof api.name !== 'string' || api.name.trim() === '') {
+                throw new Error(`接口 ${apiPath} 的 name 属性必须是非空字符串`);
+            }
+            if (typeof api.handler !== 'function') {
+                throw new Error(`接口 ${apiPath} 的 handler 属性必须是函数`);
+            }
+            // 设置默认值
+            api.method = api.method || 'POST';
+            api.auth = api.auth !== undefined ? api.auth : true;
+            // 合并默认字段：先设置自定义字段，再用默认字段覆盖（默认字段优先级更高）
+            api.fields = { ...(api.fields || {}), ...DEFAULT_API_FIELDS };
+            api.required = api.required || [];
+            // 验证可选属性的类型（如果提供了）
+            if (api.method && !['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'].includes(api.method.toUpperCase())) {
+                throw new Error(`接口 ${apiPath} 的 method 属性必须是有效的 HTTP 方法`);
+            }
+            if (api.auth !== undefined && typeof api.auth !== 'boolean') {
+                throw new Error(`接口 ${apiPath} 的 auth 属性必须是布尔值 (true=需登录, false=公开)`);
+            }
+            if (api.fields && !isPlainObject(api.fields)) {
+                throw new Error(`接口 ${apiPath} 的 fields 属性必须是对象`);
+            }
+            if (api.required && !Array.isArray(api.required)) {
+                throw new Error(`接口 ${apiPath} 的 required 属性必须是数组`);
+            }
+            if (api.required && api.required.some((item: any) => typeof item !== 'string')) {
+                throw new Error(`接口 ${apiPath} 的 required 属性必须是字符串数组`);
+            }
+            // 构建路由
+            api.route = `${api.method.toUpperCase()}/api/${routePrefix ? routePrefix + '/' : ''}${apiPath}`;
+            apiRoutes.set(api.route, api);
+        } catch (error: any) {
+            Logger.error(`[${displayName}] 接口 ${apiPath} 加载失败`, error);
+            process.exit(1);
+        }
+    }
+}
+
+/**
+ * 扫描核心 APIs
+ */
+async function scanCoreApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
+    await scanApisFromDir(coreApiDir, apiRoutes, 'core', '核心');
+}
+
+/**
+ * 扫描组件 APIs
+ */
+async function scanAddonApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
+    const addons = Addon.scan();
+
+    for (const addon of addons) {
+        if (!Addon.dirExists(addon, 'apis')) continue;
+
+        const addonApiDir = Addon.getDir(addon, 'apis');
+        await scanApisFromDir(addonApiDir, apiRoutes, `addon/${addon}`, `组件${addon}`);
+    }
+}
+
+/**
+ * 扫描用户 APIs
+ */
+async function scanUserApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
+    await scanApisFromDir(projectApiDir, apiRoutes, '', '用户');
+}
+
+/**
+ * 加载所有 API 路由
+ * @param apiRoutes - API 路由映射表
+ */
+export async function loadApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
+    try {
+        const loadStartTime = Bun.nanoseconds();
+
+        // 扫描所有 APIs
+        await scanCoreApis(apiRoutes);
+        await scanAddonApis(apiRoutes);
+        await scanUserApis(apiRoutes);
+
+        const totalLoadTime = calcPerfTime(loadStartTime);
+    } catch (error: any) {
+        Logger.error('加载 API 时发生错误', error);
+        process.exit(1);
+    }
+}