befly 3.9.38 → 3.9.39

package/lib/validator.ts

@@ -1,10 +1,11 @@
-/**
+/**
  * 数据验证器 - Befly 项目专用
  * 纯静态类设计，简洁易用
  */
 
-import { RegexAliases, getCompiledRegex } from 'befly-shared/regex';
-import type { TableDefinition, FieldDefinition, ValidateResult, SingleResult } from 'befly-shared/types';
+import type { TableDefinition, FieldDefinition, ValidateResult, SingleResult } from "../types/validate.js";
+
+import { RegexAliases, getCompiledRegex } from "../utils/regex.js";
 
 /**
  * 验证器类
@@ -30,17 +31,17 @@ export class Validator {
         const fieldErrors: Record<string, string> = {};
 
         // 参数检查
-        if (!data || typeof data !== 'object' || Array.isArray(data)) {
-            return this.buildResult({ _error: '数据必须是对象格式' });
+        if (!data || typeof data !== "object" || Array.isArray(data)) {
+            return this.buildResult({ _error: "数据必须是对象格式" });
         }
-        if (!rules || typeof rules !== 'object') {
-            return this.buildResult({ _error: '验证规则必须是对象格式' });
+        if (!rules || typeof rules !== "object") {
+            return this.buildResult({ _error: "验证规则必须是对象格式" });
         }
 
         // 检查必填字段
         for (const field of required) {
             const value = data[field];
-            if (value === undefined || value === null || value === '') {
+            if (value === undefined || value === null || value === "") {
                 const label = rules[field]?.name || field;
                 fieldErrors[field] = `${label}为必填项`;
             }
@@ -49,7 +50,8 @@ export class Validator {
         // 验证有值的字段
         for (const [field, rule] of Object.entries(rules)) {
             if (fieldErrors[field]) continue;
-            if (!(field in data) && !required.includes(field)) continue;
+            // 字段值为 undefined 时跳过验证（除非是必填字段，但必填字段已在上面检查过）
+            if (data[field] === undefined && !required.includes(field)) continue;
 
             const error = this.checkField(data[field], rule, field);
             if (error) fieldErrors[field] = error;
@@ -65,7 +67,7 @@ export class Validator {
         const { type, default: defaultValue } = fieldDef;
 
         // 处理空值
-        if (value === undefined || value === null || value === '') {
+        if (value === undefined || value === null || value === "") {
             return { value: this.defaultFor(type, defaultValue), error: null };
         }
 
@@ -118,23 +120,36 @@ export class Validator {
     /** 类型转换 */
     private static convert(value: any, type: string): { value: any; error: string | null } {
         switch (type.toLowerCase()) {
-            case 'number':
-                if (typeof value === 'number') {
-                    return Number.isNaN(value) || !isFinite(value) ? { value: null, error: '必须是有效数字' } : { value: value, error: null };
+            case "number":
+                if (typeof value === "number") {
+                    return Number.isNaN(value) || !isFinite(value) ? { value: null, error: "必须是有效数字" } : { value: value, error: null };
                 }
-                if (typeof value === 'string') {
+                if (typeof value === "string") {
                     const num = Number(value);
-                    return Number.isNaN(num) || !isFinite(num) ? { value: null, error: '必须是数字' } : { value: num, error: null };
+                    return Number.isNaN(num) || !isFinite(num) ? { value: null, error: "必须是数字" } : { value: num, error: null };
                 }
-                return { value: null, error: '必须是数字' };
+                return { value: null, error: "必须是数字" };
 
-            case 'string':
-            case 'text':
-                return typeof value === 'string' ? { value: value, error: null } : { value: null, error: '必须是字符串' };
+            case "string":
+            case "text":
+                return typeof value === "string" ? { value: value, error: null } : { value: null, error: "必须是字符串" };
 
-            case 'array_string':
-            case 'array_text':
-                return Array.isArray(value) ? { value: value, error: null } : { value: null, error: '必须是数组' };
+            case "array_string":
+            case "array_text":
+                return Array.isArray(value) ? { value: value, error: null } : { value: null, error: "必须是数组" };
+
+            case "array_number_string":
+            case "array_number_text":
+                if (!Array.isArray(value)) {
+                    return { value: null, error: "必须是数组" };
+                }
+                // 验证数组元素必须是数字
+                for (const item of value) {
+                    if (typeof item !== "number" || !isFinite(item)) {
+                        return { value: null, error: "数组元素必须是数字" };
+                    }
+                }
+                return { value: value, error: null };
 
             default:
                 return { value: value, error: null };
@@ -147,26 +162,28 @@ export class Validator {
         const regex = this.resolveRegex(regexp);
 
         switch (type.toLowerCase()) {
-            case 'number':
+            case "number":
                 if (min !== null && value < min) return `不能小于${min}`;
                 if (max !== null && max > 0 && value > max) return `不能大于${max}`;
-                if (regex && !this.testRegex(regex, String(value))) return '格式不正确';
+                if (regex && !this.testRegex(regex, String(value))) return "格式不正确";
                 break;
 
-            case 'string':
-            case 'text':
+            case "string":
+            case "text":
                 if (min !== null && value.length < min) return `长度不能少于${min}个字符`;
                 if (max !== null && max > 0 && value.length > max) return `长度不能超过${max}个字符`;
-                if (regex && !this.testRegex(regex, value)) return '格式不正确';
+                if (regex && !this.testRegex(regex, value)) return "格式不正确";
                 break;
 
-            case 'array_string':
-            case 'array_text':
+            case "array_string":
+            case "array_text":
+            case "array_number_string":
+            case "array_number_text":
                 if (min !== null && value.length < min) return `至少需要${min}个元素`;
                 if (max !== null && max > 0 && value.length > max) return `最多只能有${max}个元素`;
                 if (regex) {
                     for (const item of value) {
-                        if (!this.testRegex(regex, String(item))) return '元素格式不正确';
+                        if (!this.testRegex(regex, String(item))) return "元素格式不正确";
                     }
                 }
                 break;
@@ -177,7 +194,7 @@ export class Validator {
     /** 解析正则别名 */
     private static resolveRegex(regexp: string | null): string | null {
         if (!regexp) return null;
-        if (regexp.startsWith('@')) {
+        if (regexp.startsWith("@")) {
             const key = regexp.substring(1) as keyof typeof RegexAliases;
             return RegexAliases[key] || regexp;
         }
@@ -195,10 +212,11 @@ export class Validator {
 
     /** 获取默认值 */
     private static defaultFor(type: string, defaultValue: any): any {
+        // 如果字段定义了默认值，则使用字段默认值（优先级最高）
         if (defaultValue !== null && defaultValue !== undefined) {
             // 数组默认值
-            if ((type === 'array_string' || type === 'array_text') && typeof defaultValue === 'string') {
-                if (defaultValue === '[]') return [];
+            if ((type === "array_string" || type === "array_text" || type === "array_number_string" || type === "array_number_text") && typeof defaultValue === "string") {
+                if (defaultValue === "[]") return [];
                 try {
                     const parsed = JSON.parse(defaultValue);
                     return Array.isArray(parsed) ? parsed : [];
@@ -207,22 +225,24 @@ export class Validator {
                 }
             }
             // 数字默认值
-            if (type === 'number' && typeof defaultValue === 'string') {
+            if (type === "number" && typeof defaultValue === "string") {
                 const num = Number(defaultValue);
                 return isNaN(num) ? 0 : num;
             }
             return defaultValue;
         }
 
-        // 类型默认值
+        // 类型默认值（字段未定义 default 时使用）
         switch (type.toLowerCase()) {
-            case 'number':
+            case "number":
                 return 0;
-            case 'array_string':
-            case 'array_text':
+            case "array_string":
+            case "array_text":
+            case "array_number_string":
+            case "array_number_text":
                 return [];
             default:
-                return '';
+                return "";
         }
     }
 }

package/loader/loadApis.ts

@@ -3,55 +3,48 @@
  * 负责扫描和加载所有 API 路由（组件、项目）
  */
 
-// 内部依赖
-import { existsSync } from 'node:fs';
-
-// 外部依赖
-import { relative, basename, join } from 'pathe';
-import { isPlainObject } from 'es-toolkit/compat';
-import { scanFiles } from 'befly-shared/scanFiles';
-import { scanAddons, getAddonDir, addonDirExists } from 'befly-shared/addonHelper';
+// 类型导入
+import type { ApiRoute } from "../types/api.js";
 
+import { Logger } from "../lib/logger.js";
+import { projectApiDir } from "../paths.js";
+import { scanAddons, getAddonDir, addonDirExists } from "../utils/addonHelper.js";
+import { makeRouteKey } from "../utils/route.js";
 // 相对导入
-import { Logger } from '../lib/logger.js';
-import { projectApiDir } from '../paths.js';
-
-// 类型导入
-import type { ApiRoute } from '../types/api.js';
+import { scanFiles } from "../utils/scanFiles.js";
 
 /**
  * 预定义的默认字段
  */
 const PRESET_FIELDS: Record<string, any> = {
-    '@id': { name: 'ID', type: 'number', min: 1, max: null },
-    '@page': { name: '页码', type: 'number', min: 1, max: 9999, default: 1 },
-    '@limit': { name: '每页数量', type: 'number', min: 1, max: 100, default: 30 },
-    '@keyword': { name: '关键词', type: 'string', min: 0, max: 50 },
-    '@state': { name: '状态', type: 'number', regex: '^[0-2]$' }
+    "@id": { name: "ID", type: "number", min: 1, max: null },
+    "@page": { name: "页码", type: "number", min: 1, max: 9999, default: 1 },
+    "@limit": { name: "每页数量", type: "number", min: 1, max: 100, default: 30 },
+    "@keyword": { name: "关键词", type: "string", min: 0, max: 50 },
+    "@state": { name: "状态", type: "number", regex: "^[0-2]$" }
 };
 
 /**
- * 处理字段定义，将 @ 符号引用替换为实际字段定义
+ * 处理字段定义：将 @ 符号引用替换为实际字段定义
  */
 function processFields(fields: Record<string, any>, apiName: string, routePath: string): Record<string, any> {
-    if (!fields || typeof fields !== 'object') return fields;
+    if (!fields || typeof fields !== "object") return fields;
 
     const processed: Record<string, any> = {};
     for (const [key, value] of Object.entries(fields)) {
-        // 如果值是字符串且以 @ 开头，则查找预定义字段
-        if (typeof value === 'string' && value.startsWith('@')) {
+        if (typeof value === "string" && value.startsWith("@")) {
             if (PRESET_FIELDS[value]) {
                 processed[key] = PRESET_FIELDS[value];
-            } else {
-                // 未找到预定义字段，抛出错误
-                const validKeys = Object.keys(PRESET_FIELDS).join(', ');
-                throw new Error(`API [${apiName}] (${routePath}) 字段 [${key}] 引用了未定义的预设字段 "${value}"。可用的预设字段有: ${validKeys}`);
+                continue;
             }
-        } else {
-            // 普通字段定义，保持原样
-            processed[key] = value;
+
+            const validKeys = Object.keys(PRESET_FIELDS).join(", ");
+            throw new Error(`API [${apiName}] (${routePath}) 字段 [${key}] 引用了未定义的预设字段 "${value}"。可用的预设字段有: ${validKeys}`);
         }
+
+        processed[key] = value;
     }
+
     return processed;
 }
 
@@ -66,31 +59,31 @@ export async function loadApis(apis: Map<string, ApiRoute>): Promise<void> {
         const projectApiList = projectApiFiles.map((file) => ({
             filePath: file.filePath,
             relativePath: file.relativePath,
-            type: 'project' as const,
-            routePrefix: '/',
-            typeName: '项目'
+            type: "project" as const,
+            routePrefix: "/",
+            typeName: "项目"
         }));
 
         // 2. 扫描组件 API
         const addonApiList: Array<{
             filePath: string;
             relativePath: string;
-            type: 'addon';
+            type: "addon";
             routePrefix: string;
             typeName: string;
         }> = [];
         const addons = scanAddons();
         for (const addon of addons) {
-            if (!addonDirExists(addon, 'apis')) continue;
+            if (!addonDirExists(addon, "apis")) continue;
 
-            const addonApiDir = getAddonDir(addon, 'apis');
+            const addonApiDir = getAddonDir(addon, "apis");
             const addonApiFiles = await scanFiles(addonApiDir);
 
             for (const file of addonApiFiles) {
                 addonApiList.push({
                     filePath: file.filePath,
                     relativePath: file.relativePath,
-                    type: 'addon' as const,
+                    type: "addon" as const,
                     routePrefix: `/addon/${addon}/`, // 组件 API 默认带斜杠
                     typeName: `组件${addon}`
                 });
@@ -104,39 +97,50 @@ export async function loadApis(apis: Map<string, ApiRoute>): Promise<void> {
         for (const apiFile of allApiFiles) {
             try {
                 // Windows 下路径需要转换为正斜杠格式
-                const normalizedFilePath = apiFile.filePath.replace(/\\/g, '/');
+                const normalizedFilePath = apiFile.filePath.replace(/\\/g, "/");
                 const apiImport = await import(normalizedFilePath);
                 const api = apiImport.default;
 
+                api.name = api.name || apiFile.relativePath;
+
                 // 设置默认值
-                const methodStr = (api.method || 'POST').toUpperCase();
+                const methodStr = (api.method || "POST").toUpperCase();
                 api.auth = api.auth !== undefined ? api.auth : true;
 
                 // 构建路由路径（用于错误提示）
                 const routePath = `/api${apiFile.routePrefix}${apiFile.relativePath}`;
 
                 // 处理字段定义，将 @ 引用替换为实际字段定义
-                api.fields = processFields(api.fields || {}, api.name || apiFile.relativePath, routePath);
+                api.fields = processFields(api.fields || {}, api.name, routePath);
                 api.required = api.required || [];
 
                 // 支持逗号分隔的多方法，拆分后分别注册
                 const methods = methodStr
-                    .split(',')
+                    .split(",")
                     .map((m: string) => m.trim())
                     .filter((m: string) => m);
                 for (const method of methods) {
-                    const route = `${method}${routePath}`;
+                    const route = makeRouteKey(method, routePath);
                     // 为每个方法创建独立的路由对象
-                    const routeApi = { ...api, method: method, route: route };
+                    const routeApi: ApiRoute = {
+                        name: api.name,
+                        handler: api.handler,
+                        method: method,
+                        auth: api.auth,
+                        fields: api.fields,
+                        required: api.required,
+                        rawBody: api.rawBody,
+                        route: route
+                    };
                     apis.set(route, routeApi);
                 }
             } catch (error: any) {
-                Logger.error({ err: error, api: apiFile.relativePath, type: apiFile.typeName }, '接口加载失败');
+                Logger.error({ err: error, api: apiFile.relativePath, type: apiFile.typeName }, "接口加载失败");
                 process.exit(1);
             }
         }
     } catch (error: any) {
-        Logger.error({ err: error }, '加载 API 时发生错误');
+        Logger.error({ err: error }, "加载 API 时发生错误");
         process.exit(1);
     }
 }

package/loader/loadHooks.ts

@@ -1,31 +1,57 @@
 /**
  * 钩子加载器
- * 只加载核心钩子
+ * 默认只加载核心钩子
+ * 可选：通过配置开启组件/项目钩子（默认关闭以保持稳定性与可预期性）
  */
 
-// 相对导入
-import { Logger } from '../lib/logger.js';
-import { coreHookDir } from '../paths.js';
-import { scanModules } from '../util.js';
-import { beflyConfig } from '../befly.config.js';
-
 // 类型导入
-import type { Hook } from '../types/hook.js';
+import type { Hook } from "../types/hook.js";
+
+import { beflyConfig } from "../befly.config.js";
+import { Logger } from "../lib/logger.js";
+import { coreHookDir, projectHookDir } from "../paths.js";
+// 相对导入
+import { scanAddons, getAddonDir, addonDirExists } from "../utils/addonHelper.js";
+import { scanModules } from "../utils/modules.js";
 
 export async function loadHooks(hooks: Hook[]): Promise<void> {
     try {
+        const allHooks: Hook[] = [];
+
         // 1. 扫描核心钩子
-        const coreHooks = await scanModules<Hook>(coreHookDir, 'core', '钩子');
+        const coreHooks = await scanModules<Hook>(coreHookDir, "core", "钩子");
+        allHooks.push(...coreHooks);
+
+        // 2. 可选：扫描组件钩子（默认关闭）
+        const enableAddonHooks = Boolean((beflyConfig as any).enableAddonHooks);
+        if (enableAddonHooks) {
+            const addonHooks: Hook[] = [];
+            const addons = scanAddons();
+            for (const addon of addons) {
+                if (!addonDirExists(addon, "hooks")) continue;
+                const dir = getAddonDir(addon, "hooks");
+                const items = await scanModules<Hook>(dir, "addon", "钩子", addon);
+                addonHooks.push(...items);
+            }
+            allHooks.push(...addonHooks);
+        }
+
+        // 3. 可选：扫描项目钩子（默认关闭）
+        const enableAppHooks = Boolean((beflyConfig as any).enableAppHooks);
+        if (enableAppHooks) {
+            const appHooks = await scanModules<Hook>(projectHookDir, "app", "钩子");
+            allHooks.push(...appHooks);
+        }
 
-        // 2. 过滤禁用的钩子
+        // 4. 过滤禁用的钩子
         const disableHooks = beflyConfig.disableHooks || [];
-        const enabledHooks = coreHooks.filter((hook) => hook.name && !disableHooks.includes(hook.name));
+        const enabledHooks = allHooks.filter((hook) => hook.name && !disableHooks.includes(hook.name));
 
         if (disableHooks.length > 0) {
-            Logger.info({ hooks: disableHooks }, '禁用钩子');
+            Logger.info({ hooks: disableHooks }, "禁用钩子");
         }
 
-        // 3. 按 order 排序
+        // 5. 按 order 排序
         const sortedHooks = enabledHooks.sort((a, b) => {
             const orderA = a.order ?? 999;
             const orderB = b.order ?? 999;
@@ -34,7 +60,7 @@ export async function loadHooks(hooks: Hook[]): Promise<void> {
 
         hooks.push(...sortedHooks);
     } catch (error: any) {
-        Logger.error({ err: error }, '加载钩子时发生错误');
+        Logger.error({ err: error }, "加载钩子时发生错误");
         process.exit(1);
     }
 }

package/loader/loadPlugins.ts

@@ -3,34 +3,33 @@
  * 负责扫描和初始化所有插件（核心、组件、项目）
  */
 
-import { scanAddons, getAddonDir } from 'befly-shared/addonHelper';
+import type { BeflyContext } from "../types/befly.js";
+import type { Plugin } from "../types/plugin.js";
 
-import { Logger } from '../lib/logger.js';
-import { corePluginDir, projectPluginDir } from '../paths.js';
-import { sortModules, scanModules } from '../util.js';
-import { beflyConfig } from '../befly.config.js';
-
-import type { Plugin } from '../types/plugin.js';
-import type { BeflyContext } from '../types/befly.js';
+import { beflyConfig } from "../befly.config.js";
+import { Logger } from "../lib/logger.js";
+import { corePluginDir, projectPluginDir } from "../paths.js";
+import { scanAddons, getAddonDir } from "../utils/addonHelper.js";
+import { sortModules, scanModules } from "../utils/modules.js";
 
 export async function loadPlugins(plugins: Plugin[], context: BeflyContext): Promise<void> {
     try {
         const allPlugins: Plugin[] = [];
 
         // 1. 扫描核心插件
-        const corePlugins = await scanModules<Plugin>(corePluginDir, 'core', '插件');
+        const corePlugins = await scanModules<Plugin>(corePluginDir, "core", "插件");
 
         // 2. 扫描组件插件
         const addonPlugins: Plugin[] = [];
         const addons = scanAddons();
         for (const addon of addons) {
-            const dir = getAddonDir(addon, 'plugins');
-            const plugins = await scanModules<Plugin>(dir, 'addon', '插件', addon);
+            const dir = getAddonDir(addon, "plugins");
+            const plugins = await scanModules<Plugin>(dir, "addon", "插件", addon);
             addonPlugins.push(...plugins);
         }
 
         // 3. 扫描项目插件
-        const appPlugins = await scanModules<Plugin>(projectPluginDir, 'app', '插件');
+        const appPlugins = await scanModules<Plugin>(projectPluginDir, "app", "插件");
 
         // 4. 合并所有插件
         allPlugins.push(...corePlugins);
@@ -42,13 +41,13 @@ export async function loadPlugins(plugins: Plugin[], context: BeflyContext): Pro
         const enabledPlugins = allPlugins.filter((plugin) => plugin.name && !disablePlugins.includes(plugin.name));
 
         if (disablePlugins.length > 0) {
-            Logger.info({ plugins: disablePlugins }, '禁用插件');
+            Logger.info({ plugins: disablePlugins }, "禁用插件");
         }
 
         // 6. 排序与初始化
         const sortedPlugins = sortModules(enabledPlugins);
         if (sortedPlugins === false) {
-            Logger.error('插件依赖关系错误，请检查 after 属性');
+            Logger.error("插件依赖关系错误，请检查 after 属性");
             process.exit(1);
         }
 
@@ -56,17 +55,17 @@ export async function loadPlugins(plugins: Plugin[], context: BeflyContext): Pro
             try {
                 plugins.push(plugin);
 
-                const pluginInstance = typeof plugin.handler === 'function' ? await plugin.handler(context) : {};
+                const pluginInstance = typeof plugin.handler === "function" ? await plugin.handler(context) : {};
 
                 // 直接挂载到 befly 下
                 (context as any)[plugin.name!] = pluginInstance;
             } catch (error: any) {
-                Logger.error({ err: error, plugin: plugin.name }, '插件初始化失败');
+                Logger.error({ err: error, plugin: plugin.name }, "插件初始化失败");
                 process.exit(1);
             }
         }
     } catch (error: any) {
-        Logger.error({ err: error }, '加载插件时发生错误');
+        Logger.error({ err: error }, "加载插件时发生错误");
         process.exit(1);
     }
 }