befly 3.8.1 → 3.8.3

package/lib/redisHelper.ts

@@ -14,22 +14,22 @@ import { Database } from './database.js';
 const prefix = Env.REDIS_KEY_PREFIX ? `${Env.REDIS_KEY_PREFIX}:` : '';
 
 /**
- * 获取 Redis 客户端
- * @returns Redis 客户端实例
- * @throws 如果客户端未初始化
+ * Redis 助手类
  */
-function getClient(): RedisClient {
-    const client = Database.getRedis();
-    if (!client) {
-        throw new Error('Redis 客户端未初始化，请先调用 Database.connectRedis()');
+export class RedisHelper {
+    private client: RedisClient;
+
+    /**
+     * 构造函数
+     */
+    constructor() {
+        const client = Database.getRedis();
+        if (!client) {
+            throw new Error('Redis 客户端未初始化，请先调用 Database.connectRedis()');
+        }
+        this.client = client;
     }
-    return client;
-}
 
-/**
- * Redis 助手对象
- */
-export const RedisHelper = {
     /**
      * 设置对象到 Redis
      * @param key - 键名
@@ -39,19 +39,18 @@ export const RedisHelper = {
      */
     async setObject<T = any>(key: string, obj: T, ttl: number | null = null): Promise<string | null> {
         try {
-            const client = getClient();
             const data = JSON.stringify(obj);
             const pkey = `${prefix}${key}`;
 
             if (ttl) {
-                return await client.setex(pkey, ttl, data);
+                return await this.client.setex(pkey, ttl, data);
             }
-            return await client.set(pkey, data);
+            return await this.client.set(pkey, data);
         } catch (error: any) {
             Logger.error('Redis setObject 错误', error);
             return null;
         }
-    },
+    }
 
     /**
      * 从 Redis 获取对象
@@ -60,15 +59,14 @@ export const RedisHelper = {
      */
     async getObject<T = any>(key: string): Promise<T | null> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            const data = await client.get(pkey);
+            const data = await this.client.get(pkey);
             return data ? JSON.parse(data) : null;
         } catch (error: any) {
             Logger.error('Redis getObject 错误', error);
             return null;
         }
-    },
+    }
 
     /**
      * 从 Redis 删除对象
@@ -76,13 +74,12 @@ export const RedisHelper = {
      */
     async delObject(key: string): Promise<void> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            await client.del(pkey);
+            await this.client.del(pkey);
         } catch (error: any) {
             Logger.error('Redis delObject 错误', error);
         }
-    },
+    }
 
     /**
      * 生成基于时间的唯一 ID
@@ -92,17 +89,16 @@ export const RedisHelper = {
      * @returns 唯一 ID (14位纯数字)
      */
     async genTimeID(): Promise<number> {
-        const client = getClient();
         const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
         const key = `${prefix}time_id_counter:${timestamp}`;
 
-        const counter = await client.incr(key);
-        await client.expire(key, 1);
+        const counter = await this.client.incr(key);
+        await this.client.expire(key, 1);
 
         const counterSuffix = (counter % 10000).toString().padStart(4, '0');
 
         return Number(`${timestamp}${counterSuffix}`);
-    },
+    }
 
     /**
      * 批量生成基于时间的唯一 ID
@@ -121,13 +117,12 @@ export const RedisHelper = {
             throw new Error(`批量大小 ${count} 超过最大限制 ${MAX_BATCH_SIZE}`);
         }
 
-        const client = getClient();
         const timestamp = Math.floor(Date.now() / 1000); // 秒级时间戳
         const key = `${prefix}time_id_counter:${timestamp}`;
 
         // 使用 INCRBY 一次性获取 N 个连续计数
-        const startCounter = await client.incrby(key, count);
-        await client.expire(key, 1);
+        const startCounter = await this.client.incrby(key, count);
+        await this.client.expire(key, 1);
 
         // 生成 ID 数组
         const ids: number[] = [];
@@ -138,7 +133,7 @@ export const RedisHelper = {
         }
 
         return ids;
-    },
+    }
 
     /**
      * 设置字符串值
@@ -148,17 +143,16 @@ export const RedisHelper = {
      */
     async setString(key: string, value: string, ttl: number | null = null): Promise<string | null> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
             if (ttl) {
-                return await client.setex(pkey, ttl, value);
+                return await this.client.setex(pkey, ttl, value);
             }
-            return await client.set(pkey, value);
+            return await this.client.set(pkey, value);
         } catch (error: any) {
             Logger.error('Redis setString 错误', error);
             return null;
         }
-    },
+    }
 
     /**
      * 获取字符串值
@@ -166,14 +160,13 @@ export const RedisHelper = {
      */
     async getString(key: string): Promise<string | null> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.get(pkey);
+            return await this.client.get(pkey);
         } catch (error: any) {
             Logger.error('Redis getString 错误', error);
             return null;
         }
-    },
+    }
 
     /**
      * 检查键是否存在
@@ -181,14 +174,13 @@ export const RedisHelper = {
      */
     async exists(key: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.exists(pkey);
+            return await this.client.exists(pkey);
         } catch (error: any) {
             Logger.error('Redis exists 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 设置过期时间
@@ -197,14 +189,13 @@ export const RedisHelper = {
      */
     async expire(key: string, seconds: number): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.expire(pkey, seconds);
+            return await this.client.expire(pkey, seconds);
         } catch (error: any) {
             Logger.error('Redis expire 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 获取剩余过期时间
@@ -212,14 +203,13 @@ export const RedisHelper = {
      */
     async ttl(key: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.ttl(pkey);
+            return await this.client.ttl(pkey);
         } catch (error: any) {
             Logger.error('Redis ttl 错误', error);
             return -1;
         }
-    },
+    }
 
     /**
      * 向 Set 中添加一个或多个成员
@@ -231,14 +221,13 @@ export const RedisHelper = {
         try {
             if (members.length === 0) return 0;
 
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.sadd(pkey, ...members);
+            return await this.client.sadd(pkey, ...members);
         } catch (error: any) {
             Logger.error('Redis sadd 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 判断成员是否在 Set 中
@@ -248,14 +237,13 @@ export const RedisHelper = {
      */
     async sismember(key: string, member: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.sismember(pkey, member);
+            return await this.client.sismember(pkey, member);
         } catch (error: any) {
             Logger.error('Redis sismember 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 获取 Set 的成员数量
@@ -264,14 +252,13 @@ export const RedisHelper = {
      */
     async scard(key: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.scard(pkey);
+            return await this.client.scard(pkey);
         } catch (error: any) {
             Logger.error('Redis scard 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 获取 Set 的所有成员
@@ -280,14 +267,13 @@ export const RedisHelper = {
      */
     async smembers(key: string): Promise<string[]> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.smembers(pkey);
+            return await this.client.smembers(pkey);
         } catch (error: any) {
             Logger.error('Redis smembers 错误', error);
             return [];
         }
-    },
+    }
 
     /**
      * 删除键
@@ -296,14 +282,13 @@ export const RedisHelper = {
      */
     async del(key: string): Promise<number> {
         try {
-            const client = getClient();
             const pkey = `${prefix}${key}`;
-            return await client.del(pkey);
+            return await this.client.del(pkey);
         } catch (error: any) {
             Logger.error('Redis del 错误', error);
             return 0;
         }
-    },
+    }
 
     /**
      * 测试 Redis 连接
@@ -311,11 +296,10 @@ export const RedisHelper = {
      */
     async ping(): Promise<string> {
         try {
-            const client = getClient();
-            return await client.ping();
+            return await this.client.ping();
         } catch (error: any) {
             Logger.error('Redis ping 错误', error);
             throw error;
         }
     }
-};
+}

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/loader/loadApis.ts

@@ -0,0 +1,172 @@
+/**
+ * API 加载器
+ * 负责扫描和加载所有 API 路由（组件、用户）
+ */
+
+import { relative, basename, join } 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 { projectApiDir } from '../paths.js';
+import { scanAddons, getAddonDir, addonDirExists } from '../util.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 文件
+ */
+async function scanUserApis(): Promise<Array<{ file: string; routePrefix: string; displayName: string }>> {
+    const apis: Array<{ file: string; routePrefix: string; displayName: string }> = [];
+
+    if (!existsSync(projectApiDir)) {
+        return apis;
+    }
+
+    const glob = new Bun.Glob('**/*.ts');
+
+    for await (const file of glob.scan({
+        cwd: projectApiDir,
+        onlyFiles: true,
+        absolute: true
+    })) {
+        const apiPath = relative(projectApiDir, file).replace(/\.ts$/, '');
+        if (apiPath.indexOf('_') !== -1) continue;
+
+        apis.push({
+            file: file,
+            routePrefix: '',
+            displayName: '用户'
+        });
+    }
+
+    return apis;
+}
+
+/**
+ * 扫描组件 API 文件
+ */
+async function scanAddonApis(): Promise<Array<{ file: string; routePrefix: string; displayName: string }>> {
+    const apis: Array<{ file: string; routePrefix: string; displayName: string }> = [];
+    const glob = new Bun.Glob('**/*.ts');
+    const addons = scanAddons();
+
+    for (const addon of addons) {
+        if (!addonDirExists(addon, 'apis')) continue;
+
+        const addonApiDir = getAddonDir(addon, 'apis');
+        for await (const file of glob.scan({
+            cwd: addonApiDir,
+            onlyFiles: true,
+            absolute: true
+        })) {
+            const apiPath = relative(addonApiDir, file).replace(/\.ts$/, '');
+            if (apiPath.indexOf('_') !== -1) continue;
+
+            apis.push({
+                file: file,
+                routePrefix: `addon/${addon}`,
+                displayName: `组件${addon}`
+            });
+        }
+    }
+
+    return apis;
+}
+
+/**
+ * 初始化单个 API
+ */
+async function initApi(apiRoutes: Map<string, ApiRoute>, apiInfo: { file: string; routePrefix: string; displayName: string }): Promise<void> {
+    const { file, routePrefix, displayName } = apiInfo;
+    const apiDir = routePrefix === '' ? projectApiDir : getAddonDir(routePrefix.replace('addon/', ''), 'apis');
+    const apiPath = relative(apiDir, file).replace(/\.ts$/, '');
+
+    try {
+        // Windows 下路径需要转换为正斜杠格式
+        const filePath = file.replace(/\\/g, '/');
+        const apiImport = await import(filePath);
+        const api = apiImport.default;
+
+        // 设置默认值
+        api.method = api.method || 'POST';
+        api.auth = api.auth !== undefined ? api.auth : true;
+        // 合并默认字段：先设置自定义字段，再用默认字段覆盖（默认字段优先级更高）
+        api.fields = { ...(api.fields || {}), ...DEFAULT_API_FIELDS };
+        api.required = api.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);
+    }
+}
+
+/**
+ * 加载所有 API 路由
+ * @param apiRoutes - API 路由映射表
+ */
+export async function loadApis(apiRoutes: Map<string, ApiRoute>): Promise<void> {
+    try {
+        const loadStartTime = Bun.nanoseconds();
+
+        // 阶段1：扫描所有 API
+        const userApis = await scanUserApis();
+        const addonApis = await scanAddonApis();
+
+        // 阶段2：初始化所有 API（用户 → 组件）
+        // 2.1 初始化用户 APIs
+        for (const apiInfo of userApis) {
+            await initApi(apiRoutes, apiInfo);
+        }
+
+        // 2.2 初始化组件 APIs
+        for (const apiInfo of addonApis) {
+            await initApi(apiRoutes, apiInfo);
+        }
+
+        const totalLoadTime = calcPerfTime(loadStartTime);
+    } catch (error: any) {
+        Logger.error('加载 API 时发生错误', error);
+        process.exit(1);
+    }
+}