befly 3.10.18 → 3.11.1

package/dist/lib/sqlCheck.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SQL 入参校验工具（静态类）
+ *
+ * 目标：把“参数合法性/一致性/安全性”判断从 SqlBuilder 等拼接逻辑中拆出来，便于复用与维护。
+ *
+ * 说明：这里的校验仅关注“字符串/标识符/批量数据结构”层面的正确性；
+ * 具体 SQL 语义（如字段是否存在）不在此处校验。
+ */
+export declare class SqlCheck {
+    private static readonly SAFE_IDENTIFIER_RE;
+    static assertNonEmptyString(value: unknown, label: string): asserts value is string;
+    static assertNoUndefinedParam(value: unknown, label: string): void;
+    static startsWithQuote(value: string): boolean;
+    static isQuotedIdentPaired(value: string): boolean;
+    static assertPairedQuotedIdentIfStartsWithQuote(value: string, label: string): void;
+    static assertSafeIdentifierPart(part: string, kind: "table" | "schema" | "alias" | "field"): void;
+    static assertSafeAlias(aliasPart: string): void;
+    static assertNoExprField(field: string): void;
+    static assertNoUndefinedInRecord(row: Record<string, unknown>, label: string): void;
+    static assertBatchInsertRowsConsistent(rows: Array<Record<string, unknown>>, options: {
+        table: string;
+    }): string[];
+}

package/{lib/sqlCheck.ts → dist/lib/sqlCheck.js}

@@ -6,11 +6,9 @@
  * 说明：这里的校验仅关注“字符串/标识符/批量数据结构”层面的正确性；
  * 具体 SQL 语义（如字段是否存在）不在此处校验。
  */
-
 export class SqlCheck {
-    private static readonly SAFE_IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-
-    static assertNonEmptyString(value: unknown, label: string): asserts value is string {
+    static SAFE_IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    static assertNonEmptyString(value, label) {
         if (typeof value !== "string") {
             throw new Error(`${label} 必须是字符串 (value: ${String(value)})`);
         }
@@ -18,119 +16,104 @@ export class SqlCheck {
             throw new Error(`${label} 不能为空`);
         }
     }
-
-    static assertNoUndefinedParam(value: unknown, label: string): void {
+    static assertNoUndefinedParam(value, label) {
         if (value === undefined) {
             throw new Error(`${label} 不能为 undefined`);
         }
     }
-
-    static startsWithQuote(value: string): boolean {
+    static startsWithQuote(value) {
         const trimmed = value.trim();
         return trimmed.startsWith("`") || trimmed.startsWith('"');
     }
-
-    static isQuotedIdentPaired(value: string): boolean {
+    static isQuotedIdentPaired(value) {
         const trimmed = value.trim();
-        if (trimmed.length < 2) return false;
-
+        if (trimmed.length < 2)
+            return false;
         const first = trimmed[0];
         const last = trimmed[trimmed.length - 1];
-
-        if (first === "`" && last === "`") return true;
-        if (first === '"' && last === '"') return true;
-
+        if (first === "`" && last === "`")
+            return true;
+        if (first === '"' && last === '"')
+            return true;
         return false;
     }
-
-    static assertPairedQuotedIdentIfStartsWithQuote(value: string, label: string): void {
+    static assertPairedQuotedIdentIfStartsWithQuote(value, label) {
         if (SqlCheck.startsWithQuote(value) && !SqlCheck.isQuotedIdentPaired(value)) {
             throw new Error(`${label} 引用不完整，请使用成对的 \`...\` 或 "..." (value: ${value})`);
         }
     }
-
-    static assertSafeIdentifierPart(part: string, kind: "table" | "schema" | "alias" | "field"): void {
+    static assertSafeIdentifierPart(part, kind) {
         // 这里仅允许常规标识符（字母/数字/下划线），避免把复杂表达式混进“自动转义”路径。
         if (!SqlCheck.SAFE_IDENTIFIER_RE.test(part)) {
             throw new Error(`无效的 ${kind} 标识符: ${part}`);
         }
     }
-
-    static assertSafeAlias(aliasPart: string): void {
+    static assertSafeAlias(aliasPart) {
         // alias 允许两种：
         // 1) 已经被引用（`alias` 或 "alias"）
         // 2) 普通标识符（不允许带空格/符号），避免注入
-        if (SqlCheck.isQuotedIdentPaired(aliasPart)) return;
+        if (SqlCheck.isQuotedIdentPaired(aliasPart))
+            return;
         if (!SqlCheck.SAFE_IDENTIFIER_RE.test(aliasPart)) {
             throw new Error(`无效的字段别名: ${aliasPart}`);
         }
     }
-
-    static assertNoExprField(field: string): void {
-        if (typeof field !== "string") return;
+    static assertNoExprField(field) {
+        if (typeof field !== "string")
+            return;
         const trimmed = field.trim();
-        if (!trimmed) return;
-
+        if (!trimmed)
+            return;
         // 收紧：包含函数/表达式（括号）不允许走自动转义路径
         // 这类表达式应显式使用 selectRaw/whereRaw 以避免误拼接和注入风险
         if (trimmed.includes("(") || trimmed.includes(")")) {
             throw new Error(`字段包含函数/表达式，请使用 selectRaw/whereRaw (field: ${trimmed})`);
         }
     }
-
-    static assertNoUndefinedInRecord(row: Record<string, unknown>, label: string): void {
+    static assertNoUndefinedInRecord(row, label) {
         for (const [key, value] of Object.entries(row)) {
             if (value === undefined) {
                 throw new Error(`${label} 存在 undefined 字段值 (field: ${key})`);
             }
         }
     }
-
-    static assertBatchInsertRowsConsistent(rows: Array<Record<string, unknown>>, options: { table: string }): string[] {
+    static assertBatchInsertRowsConsistent(rows, options) {
         if (!Array.isArray(rows)) {
             throw new Error("批量插入 rows 必须是数组");
         }
         if (rows.length === 0) {
             throw new Error(`插入数据不能为空 (table: ${options.table})`);
         }
-
         const first = rows[0];
         if (!first || typeof first !== "object" || Array.isArray(first)) {
             throw new Error(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: 0)`);
         }
-
         const fields = Object.keys(first);
         if (fields.length === 0) {
             throw new Error(`插入数据必须至少有一个字段 (table: ${options.table})`);
         }
-
         const fieldSet = new Set(fields);
-
         for (let i = 0; i < rows.length; i++) {
             const row = rows[i];
             if (!row || typeof row !== "object" || Array.isArray(row)) {
                 throw new Error(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: ${i})`);
             }
-
             const rowKeys = Object.keys(row);
             if (rowKeys.length !== fields.length) {
                 throw new Error(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i})`);
             }
-
             for (const key of rowKeys) {
                 if (!fieldSet.has(key)) {
                     throw new Error(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i}, extraField: ${key})`);
                 }
             }
-
             for (const field of fields) {
                 if (!(field in row)) {
                     throw new Error(`批量插入缺少字段 (table: ${options.table}, rowIndex: ${i}, field: ${field})`);
                 }
-                SqlCheck.assertNoUndefinedParam((row as any)[field], `批量插入字段值 (table: ${options.table}, rowIndex: ${i}, field: ${field})`);
+                SqlCheck.assertNoUndefinedParam(row[field], `批量插入字段值 (table: ${options.table}, rowIndex: ${i}, field: ${field})`);
             }
         }
-
         return fields;
     }
 }

package/dist/lib/validator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 数据验证器 - Befly 项目专用
+ * 纯静态类设计，简洁易用
+ */
+import type { TableDefinition, FieldDefinition, ValidateResult, SingleResult } from "../types/validate";
+/**
+ * 验证器类
+ *
+ * @example
+ * const result = Validator.validate(data, rules, ['email', 'name']);
+ * if (result.failed) {
+ *     console.log(result.firstError);
+ *     console.log(result.errors);
+ *     console.log(result.errorFields);
+ * }
+ *
+ * const single = Validator.single(value, fieldDef);
+ * if (!single.error) {
+ *     console.log(single.value);
+ * }
+ */
+export declare class Validator {
+    /**
+     * 验证数据对象
+     */
+    static validate(data: Record<string, any>, rules: TableDefinition, required?: string[]): ValidateResult;
+    /**
+     * 验证单个值（带类型转换）
+     */
+    static single(value: any, fieldDef: FieldDefinition): SingleResult;
+    /** 构建结果对象 */
+    private static buildResult;
+    /** 验证单个字段 */
+    private static checkField;
+    /** 类型转换 */
+    private static convert;
+    /** 规则验证 */
+    private static checkRule;
+    /** 解析正则别名 */
+    private static resolveRegex;
+    /** 测试正则 */
+    private static testRegex;
+    /** 获取默认值 */
+    private static defaultFor;
+}

package/{lib/validator.ts → dist/lib/validator.js}

@@ -2,11 +2,7 @@
  * 数据验证器 - Befly 项目专用
  * 纯静态类设计，简洁易用
  */
-
-import type { TableDefinition, FieldDefinition, ValidateResult, SingleResult } from "../types/validate.ts";
-
-import { RegexAliases, getCompiledRegex } from "../configs/presetRegexp.ts";
-
+import { RegexAliases, getCompiledRegex } from "../configs/presetRegexp";
 /**
  * 验证器类
  *
@@ -27,9 +23,8 @@ export class Validator {
     /**
      * 验证数据对象
      */
-    static validate(data: Record<string, any>, rules: TableDefinition, required: string[] = []): ValidateResult {
-        const fieldErrors: Record<string, string> = {};
-
+    static validate(data, rules, required = []) {
+        const fieldErrors = {};
         // 参数检查
         if (!data || typeof data !== "object" || Array.isArray(data)) {
             return this.buildResult({ _error: "数据必须是对象格式" });
@@ -37,7 +32,6 @@ export class Validator {
         if (!rules || typeof rules !== "object") {
             return this.buildResult({ _error: "验证规则必须是对象格式" });
         }
-
         // 检查必填字段
         for (const field of required) {
             const value = data[field];
@@ -46,54 +40,46 @@ export class Validator {
                 fieldErrors[field] = `${label}为必填项`;
             }
         }
-
         // 验证有值的字段
         for (const [field, rule] of Object.entries(rules)) {
-            if (fieldErrors[field]) continue;
+            if (fieldErrors[field])
+                continue;
             // 字段值为 undefined 时跳过验证（除非是必填字段，但必填字段已在上面检查过）
-            if (data[field] === undefined && !required.includes(field)) continue;
-
+            if (data[field] === undefined && !required.includes(field))
+                continue;
             const error = this.checkField(data[field], rule, field);
-            if (error) fieldErrors[field] = error;
+            if (error)
+                fieldErrors[field] = error;
         }
-
         return this.buildResult(fieldErrors);
     }
-
     /**
      * 验证单个值（带类型转换）
      */
-    static single(value: any, fieldDef: FieldDefinition): SingleResult {
+    static single(value, fieldDef) {
         const { type, default: defaultValue } = fieldDef;
-
         // 处理空值
         if (value === undefined || value === null || value === "") {
             return { value: this.defaultFor(type, defaultValue), error: null };
         }
-
         // 类型转换
         const converted = this.convert(value, type);
         if (converted.error) {
             return { value: null, error: converted.error };
         }
-
         // 规则验证
         const error = this.checkRule(converted.value, fieldDef);
         if (error) {
             return { value: null, error: error };
         }
-
         return { value: converted.value, error: null };
     }
-
     // ========== 私有方法 ==========
-
     /** 构建结果对象 */
-    private static buildResult(fieldErrors: Record<string, string>): ValidateResult {
+    static buildResult(fieldErrors) {
         const errors = Object.values(fieldErrors);
         const errorFields = Object.keys(fieldErrors);
         const failed = errors.length > 0;
-
         return {
             code: failed ? 1 : 0,
             failed: failed,
@@ -103,22 +89,18 @@ export class Validator {
             fieldErrors: fieldErrors
         };
     }
-
     /** 验证单个字段 */
-    private static checkField(value: any, fieldDef: FieldDefinition, fieldName: string): string | null {
+    static checkField(value, fieldDef, fieldName) {
         const label = fieldDef.name || fieldName;
-
         const converted = this.convert(value, fieldDef.type);
         if (converted.error) {
             return `${label}${converted.error}`;
         }
-
         const error = this.checkRule(converted.value, fieldDef);
         return error ? `${label}${error}` : null;
     }
-
     /** 类型转换 */
-    private static convert(value: any, type: string): { value: any; error: string | null } {
+    static convert(value, type) {
         switch (type.toLowerCase()) {
             case "number":
                 if (typeof value === "number") {
@@ -129,15 +111,12 @@ export class Validator {
                     return Number.isNaN(num) || !isFinite(num) ? { value: null, error: "必须是数字" } : { value: num, error: null };
                 }
                 return { 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_number_string":
             case "array_number_text":
                 if (!Array.isArray(value)) {
@@ -150,77 +129,82 @@ export class Validator {
                     }
                 }
                 return { value: value, error: null };
-
             default:
                 return { value: value, error: null };
         }
     }
-
     /** 规则验证 */
-    private static checkRule(value: any, fieldDef: FieldDefinition): string | null {
+    static checkRule(value, fieldDef) {
         const { type, min, max, regexp } = fieldDef;
         const regex = this.resolveRegex(regexp);
-
         switch (type.toLowerCase()) {
             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 (min !== null && value < min)
+                    return `不能小于${min}`;
+                if (max !== null && max > 0 && value > max)
+                    return `不能大于${max}`;
+                if (regex && !this.testRegex(regex, String(value)))
+                    return "格式不正确";
                 break;
-
             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 (min !== null && value.length < min)
+                    return `长度不能少于${min}个字符`;
+                if (max !== null && max > 0 && value.length > max)
+                    return `长度不能超过${max}个字符`;
+                if (regex && !this.testRegex(regex, value))
+                    return "格式不正确";
                 break;
-
             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 (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;
         }
         return null;
     }
-
     /** 解析正则别名 */
-    private static resolveRegex(regexp: string | null): string | null {
-        if (!regexp) return null;
+    static resolveRegex(regexp) {
+        if (!regexp)
+            return null;
         if (regexp.startsWith("@")) {
-            const key = regexp.substring(1) as keyof typeof RegexAliases;
+            const key = regexp.substring(1);
             return RegexAliases[key] || regexp;
         }
         return regexp;
     }
-
     /** 测试正则 */
-    private static testRegex(pattern: string, value: string): boolean {
+    static testRegex(pattern, value) {
         try {
             return getCompiledRegex(pattern).test(value);
-        } catch {
+        }
+        catch {
             return false;
         }
     }
-
     /** 获取默认值 */
-    private static defaultFor(type: string, defaultValue: any): any {
+    static defaultFor(type, defaultValue) {
         // 如果字段定义了默认值，则使用字段默认值（优先级最高）
         if (defaultValue !== null && defaultValue !== undefined) {
             // 数组默认值
             if ((type === "array_string" || type === "array_text" || type === "array_number_string" || type === "array_number_text") && typeof defaultValue === "string") {
-                if (defaultValue === "[]") return [];
+                if (defaultValue === "[]")
+                    return [];
                 try {
                     const parsed = JSON.parse(defaultValue);
                     return Array.isArray(parsed) ? parsed : [];
-                } catch {
+                }
+                catch {
                     return [];
                 }
             }
@@ -231,7 +215,6 @@ export class Validator {
             }
             return defaultValue;
         }
-
         // 类型默认值（字段未定义 default 时使用）
         switch (type.toLowerCase()) {
             case "number":

package/dist/loader/loadApis.d.ts

@@ -0,0 +1,12 @@
+/**
+ * API 加载器
+ * 负责扫描和加载所有 API 路由（组件、项目）
+ */
+import type { ApiRoute } from "../types/api";
+import type { ScanFileResult } from "../utils/scanFiles";
+/**
+ * 加载所有 API 路由
+ * @param apiItems - scanSources/scanFiles 扫描到的 API 条目数组
+ * @returns API 路由映射表
+ */
+export declare function loadApis(apis: ScanFileResult[]): Promise<Map<string, ApiRoute>>;

package/{loader/loadApis.ts → dist/loader/loadApis.js}

@@ -2,42 +2,32 @@
  * API 加载器
  * 负责扫描和加载所有 API 路由（组件、项目）
  */
-
-// 类型导入
-import type { ApiRoute } from "../types/api.ts";
-import type { ScanFileResult } from "../utils/scanFiles.ts";
-
-import { Logger } from "../lib/logger.ts";
-import { processFields } from "../utils/processFields.ts";
-
+import { Logger } from "../lib/logger";
+import { processAtSymbol } from "../utils/processAtSymbol";
 /**
  * 加载所有 API 路由
  * @param apiItems - scanSources/scanFiles 扫描到的 API 条目数组
  * @returns API 路由映射表
  */
-export async function loadApis(apis: ScanFileResult[]): Promise<Map<string, ApiRoute>> {
-    const apisMap = new Map<string, ApiRoute>();
-
+export async function loadApis(apis) {
+    const apisMap = new Map();
     for (const api of apis) {
-        const apiType = (api as any).type;
+        const apiType = api.type;
         // 兼容：scanFiles 的结果或测试构造数据可能缺少 type 字段；缺少时默认按 API 处理。
         // 仅在 type 显式存在且不等于 "api" 时跳过，避免错误过滤。
         if (apiType && apiType !== "api") {
             continue;
         }
-
         try {
-            const apiRoute = api as any;
-
+            const apiRoute = api;
             // 处理字段定义，将 @ 引用替换为实际字段定义
-            apiRoute.fields = processFields(apiRoute.fields || {}, apiRoute.name, apiRoute.routePath);
-
-            apisMap.set(apiRoute.routePath, apiRoute as ApiRoute);
-        } catch (error: any) {
+            apiRoute.fields = processAtSymbol(apiRoute.fields || {}, apiRoute.name, apiRoute.routePath);
+            apisMap.set(apiRoute.routePath, apiRoute);
+        }
+        catch (error) {
             Logger.error({ err: error, api: api.relativePath, file: api.filePath }, "接口加载失败");
             throw error;
         }
     }
-
     return apisMap;
 }

package/dist/loader/loadHooks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 钩子加载器
+ * 默认加载所有来源钩子（core/addon/app）
+ */
+import type { Hook } from "../types/hook";
+import type { ScanFileResult } from "../utils/scanFiles";
+export declare function loadHooks(hooks: ScanFileResult[]): Promise<Hook[]>;

package/dist/loader/loadHooks.js

@@ -0,0 +1,35 @@
+/**
+ * 钩子加载器
+ * 默认加载所有来源钩子（core/addon/app）
+ */
+import { sortModules } from "../utils/sortModules";
+export async function loadHooks(hooks) {
+    const hooksMap = [];
+    const enabledHooks = hooks.filter((item) => {
+        const moduleName = item?.moduleName;
+        if (typeof moduleName !== "string" || moduleName.trim() === "") {
+            return false;
+        }
+        // enable=false 表示禁用（替代 disableHooks 列表）。
+        // enable 仅允许 boolean；缺失 enable 的默认值应在 checkHook 阶段被补全为 true。
+        if (item?.enable === false) {
+            return false;
+        }
+        return true;
+    });
+    const sortedHooks = sortModules(enabledHooks, { moduleLabel: "钩子" });
+    if (sortedHooks === false) {
+        throw new Error("钩子依赖关系错误");
+    }
+    for (const item of sortedHooks) {
+        const hookName = item.moduleName;
+        const hook = item;
+        hooksMap.push({
+            name: hookName,
+            enable: true,
+            deps: hook.deps,
+            handler: hook.handler
+        });
+    }
+    return hooksMap;
+}

package/dist/loader/loadPlugins.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 插件加载器
+ * 负责扫描和初始化所有插件（核心、组件、项目）
+ */
+import type { BeflyContext } from "../types/befly";
+import type { Plugin } from "../types/plugin";
+import type { ScanFileResult } from "../utils/scanFiles";
+export declare function loadPlugins(plugins: ScanFileResult[], context: BeflyContext): Promise<Plugin[]>;

package/{loader/loadPlugins.ts → dist/loader/loadPlugins.js}

@@ -2,55 +2,43 @@
  * 插件加载器
  * 负责扫描和初始化所有插件（核心、组件、项目）
  */
-
-import type { BeflyContext } from "../types/befly.ts";
-import type { Plugin } from "../types/plugin.ts";
-import type { ScanFileResult } from "../utils/scanFiles.ts";
-
-import { Logger } from "../lib/logger.ts";
-import { sortModules } from "../utils/sortModules.ts";
-
-export async function loadPlugins(plugins: ScanFileResult[], context: BeflyContext, disablePlugins: string[] = []): Promise<Plugin[]> {
-    const pluginsMap: Plugin[] = [];
-
-    if (disablePlugins.length > 0) {
-        Logger.info({ plugins: disablePlugins }, "禁用插件");
-    }
-
-    const enabledPlugins = plugins.filter((item: any) => {
+import { Logger } from "../lib/logger";
+import { sortModules } from "../utils/sortModules";
+export async function loadPlugins(plugins, context) {
+    const pluginsMap = [];
+    const enabledPlugins = plugins.filter((item) => {
         const moduleName = item?.moduleName;
         if (typeof moduleName !== "string" || moduleName.trim() === "") {
             return false;
         }
-        if (disablePlugins.includes(moduleName)) {
+        // enable=false 表示禁用（替代 disablePlugins 列表）。
+        // enable 仅允许 boolean；缺失 enable 的默认值应在 checkPlugin 阶段被补全为 true。
+        if (item?.enable === false) {
             return false;
         }
         return true;
     });
-
     const sortedPlugins = sortModules(enabledPlugins, { moduleLabel: "插件" });
     if (sortedPlugins === false) {
         throw new Error("插件依赖关系错误");
     }
-
     for (const item of sortedPlugins) {
-        const pluginName = (item as any).moduleName as string;
-        const plugin = item as any as Plugin;
-
+        const pluginName = item.moduleName;
+        const plugin = item;
         try {
             const pluginInstance = typeof plugin.handler === "function" ? await plugin.handler(context) : {};
-            (context as any)[pluginName] = pluginInstance;
-
+            context[pluginName] = pluginInstance;
             pluginsMap.push({
                 name: pluginName,
+                enable: true,
                 deps: plugin.deps,
                 handler: plugin.handler
             });
-        } catch (error: any) {
+        }
+        catch (error) {
             Logger.error({ err: error, plugin: pluginName }, "插件初始化失败");
             throw error;
         }
     }
-
     return pluginsMap;
 }