befly 3.76.0 → 3.76.2

package/apis/role/menuSave.js

@@ -11,9 +11,9 @@ export default {
         roleCode: roleTable.code,
         menuPaths: roleTable.menus
     },
-    required: ["roleCode"],
+    required: ["roleCode", "menuPaths"],
     handler: async (befly, ctx) => {
-        const menuPaths = ctx.body.menuPaths || [];
+        const menuPaths = ctx.body.menuPaths;
 
         const role = await getRoleByCode(befly, ctx.body.roleCode);
 

package/apis/role/select.js

@@ -1,15 +1,10 @@
-import { queryFields } from "#befly/apis/_apis.js";
-import roleTable from "#befly/tables/role.json";
-
 export default {
     name: "获取角色列表",
+    category: "select",
     method: "POST",
     body: "none",
     auth: true,
-    fields: {
-        ...queryFields,
-        state: roleTable.state
-    },
+    fields: {},
     required: [],
     handler: async (befly, ctx) => {
         const roles = await befly.mysql.getList({

package/apis/source/imageList.js

@@ -1,13 +1,10 @@
-import { queryFields } from "#befly/apis/_apis.js";
-
 export default {
     name: "获取图库列表",
+    category: "select",
     method: "POST",
     body: "none",
     auth: true,
-    fields: {
-        ...queryFields
-    },
+    fields: {},
     required: [],
     handler: async (befly, ctx) => {
         const result = await befly.mysql.getList({

package/apis/tongJi/dailyReport.js

@@ -1,4 +1,3 @@
-import { Logger } from "#befly/lib/logger.js";
 import { isValidPositiveInt } from "#befly/utils/is.js";
 
 import { getTongJiDateYmdNumber } from "./_tongJi.js";
@@ -11,17 +10,17 @@ export default {
     body: "none",
     auth: false,
     fields: {
-        clientType: { name: "客户端类型", input: "enum", check: "browser|vscode|desktop|miniapp|app", min: 3, max: 20 },
-        clientId: { name: "客户端标识", input: "string", min: 0, max: 120 },
-        productName: { name: "产品名称", input: "string", min: 0, max: 100 },
-        productCode: { name: "产品代号", input: "string", min: 0, max: 100 },
-        productVersion: { name: "产品版本", input: "string", min: 0, max: 50 },
-        clientVersion: { name: "客户端版本", input: "string", min: 0, max: 100 },
-        os: { name: "操作系统", input: "string", min: 0, max: 100 },
-        deviceId: { name: "设备标识", input: "string", min: 0, max: 120 },
-        brand: { name: "设备品牌", input: "string", min: 0, max: 100 },
-        model: { name: "设备型号", input: "string", min: 0, max: 100 },
-        system: { name: "系统", input: "string", min: 0, max: 100 }
+        clientType: { name: "客户端类型", paramType: "string", enum: ["browser", "vscode", "desktop", "miniapp", "app"], minValue: 3, maxValue: 20 },
+        clientId: { name: "客户端标识", paramType: "string", minValue: 0, maxValue: 120 },
+        productName: { name: "产品名称", paramType: "string", minValue: 0, maxValue: 100 },
+        productCode: { name: "产品代号", paramType: "string", minValue: 0, maxValue: 100 },
+        productVersion: { name: "产品版本", paramType: "string", minValue: 0, maxValue: 50 },
+        clientVersion: { name: "客户端版本", paramType: "string", minValue: 0, maxValue: 100 },
+        os: { name: "操作系统", paramType: "string", minValue: 0, maxValue: 100 },
+        deviceId: { name: "设备标识", paramType: "string", minValue: 0, maxValue: 120 },
+        brand: { name: "设备品牌", paramType: "string", minValue: 0, maxValue: 100 },
+        model: { name: "设备型号", paramType: "string", minValue: 0, maxValue: 100 },
+        system: { name: "系统", paramType: "string", minValue: 0, maxValue: 100 }
     },
     required: ["clientType"],
     handler: async (befly, ctx) => {
@@ -84,7 +83,7 @@ export default {
                 await befly.mysql.insData({ table: "beflyDailyReport", data: row });
                 stored = true;
             } catch (error) {
-                Logger.error("daily_report 落盘失败", error);
+                befly.logger.error("daily_report 落盘失败", error);
             }
         }
 

package/apis/tongJi/dailyReportSelect.js

@@ -1,13 +1,12 @@
-import { queryFields } from "#befly/apis/_apis.js";
 import dailyReportTable from "#befly/tables/dailyReport.json";
 
 export default {
     name: "获取日报记录列表",
+    category: "select",
     method: "POST",
     body: "none",
     auth: true,
     fields: {
-        ...queryFields,
         productCode: dailyReportTable.productCode,
         clientType: dailyReportTable.clientType,
         reportDate: dailyReportTable.reportDate,

package/apis/tongJi/dailyStats.js

@@ -137,7 +137,7 @@ export default {
     body: "none",
     auth: true,
     fields: {
-        productCode: { name: "产品代号", input: "string", min: 0, max: 100 }
+        productCode: { name: "产品代号", paramType: "string", minValue: 0, maxValue: 100 }
     },
     required: [],
     handler: async (befly, ctx) => {

package/apis/tongJi/dailyStatsDistribution.js

@@ -62,8 +62,8 @@ export default {
     body: "none",
     auth: true,
     fields: {
-        productCode: { name: "产品代号", input: "string", min: 1, max: 100 },
-        dateRange: { name: "日期范围", input: "enum", check: "today|yesterday|dayBeforeYesterday|recent30|month", min: 1, max: 20 }
+        productCode: { name: "产品代号", paramType: "string", minValue: 1, maxValue: 100 },
+        dateRange: { name: "日期范围", paramType: "string", enum: ["today", "yesterday", "dayBeforeYesterday", "recent30", "month"], minValue: 1, maxValue: 20 }
     },
     required: ["productCode", "dateRange"],
     handler: async (befly, ctx) => {

package/apis/tongJi/errorList.js

@@ -1,4 +1,3 @@
-import { queryFields } from "#befly/apis/_apis.js";
 import errorReportTable from "#befly/tables/errorReport.json";
 
 const NUMBER_FIELDS = ["reportTime", "firstReportTime", "bucketTime", "bucketDate"];
@@ -7,11 +6,11 @@ const KEYWORD_FIELDS = ["pagePath", "pageName", "message", "errorType", "product
 
 export default {
     name: "获取错误报告列表",
+    category: "select",
     method: "POST",
     body: "none",
     auth: true,
     fields: {
-        ...queryFields,
         errorType: errorReportTable.errorType,
         productName: errorReportTable.productName,
         productCode: errorReportTable.productCode,

package/apis/tongJi/errorReport.js

@@ -1,4 +1,3 @@
-import { Logger } from "#befly/lib/logger.js";
 import errorReportTable from "#befly/tables/errorReport.json";
 import { getDateYmdNumber, getTimeBucketStart } from "#befly/utils/datetime.js";
 import { isValidPositiveInt } from "#befly/utils/is.js";
@@ -111,7 +110,7 @@ export default {
                 await befly.mysql.insData({ table: "beflyErrorReport", data: data });
                 stored = true;
             } catch (error) {
-                Logger.error("errorReport 插入失败", error);
+                befly.logger.error("errorReport 插入失败", error);
             }
         }
 

package/apis/tongJi/projectDelete.js

@@ -1,12 +1,10 @@
-import projectTable from "#befly/tables/project.json";
-
 export default {
     name: "删除产品",
     method: "POST",
     body: "none",
     auth: true,
     fields: {
-        id: projectTable.id
+        id: { name: "ID", paramType: "integer", minValue: 1 }
     },
     required: ["id"],
     handler: async (befly, ctx) => {

package/apis/tongJi/projectSelect.js

@@ -1,15 +1,13 @@
-import { queryFields } from "#befly/apis/_apis.js";
 import projectTable from "#befly/tables/project.json";
 
 export default {
     name: "获取产品列表",
+    category: "select",
     method: "POST",
     body: "none",
     auth: true,
     fields: {
-        ...queryFields,
-        code: projectTable.code,
-        state: projectTable.state
+        code: projectTable.code
     },
     required: [],
     handler: async (befly, ctx) => {

package/apis/tongJi/projectUpdate.js

@@ -6,11 +6,11 @@ export default {
     body: "none",
     auth: true,
     fields: {
-        id: projectTable.id,
+        id: { name: "ID", paramType: "integer", minValue: 1 },
         code: projectTable.code,
         name: projectTable.name,
         sort: projectTable.sort,
-        state: projectTable.state
+        state: { name: "状态", paramType: "integer" }
     },
     required: ["id"],
     handler: async (befly, ctx) => {

package/apis/upload/file.js

@@ -1,7 +1,6 @@
-import { mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { extname, join } from "node:path";
 
-import { Logger } from "#befly/lib/logger.js";
 import { getAppPublicDir } from "#befly/paths.js";
 import { getMonthDir } from "#befly/utils/datetime.js";
 
@@ -13,6 +12,7 @@ export default {
     fields: {},
     required: [],
     handler: async (befly, ctx) => {
+        let savedFilePath;
         try {
             const maxFileSizeMb = Number(befly.config.upload.maxSize);
             const maxFileSize = maxFileSizeMb * 1024 * 1024;
@@ -78,7 +78,8 @@ export default {
             const isImage = fileType === "image" ? 1 : 0;
 
             mkdirSync(uploadDir, { recursive: true });
-            await Bun.write(join(uploadDir, savedFileName), rawBuffer);
+            savedFilePath = join(uploadDir, savedFileName);
+            await Bun.write(savedFilePath, rawBuffer);
 
             const insertRes = await befly.mysql.insData({
                 table: "beflyFile",
@@ -96,7 +97,7 @@ export default {
             });
 
             if (!insertRes.data) {
-                return befly.tool.No("资源记录写入失败");
+                throw new Error("资源记录写入失败");
             }
 
             return befly.tool.Yes("上传成功", {
@@ -112,7 +113,8 @@ export default {
                 url: absoluteFileUrl
             });
         } catch (error) {
-            Logger.error("上传文件失败", error, {
+            if (savedFilePath && existsSync(savedFilePath)) unlinkSync(savedFilePath);
+            befly.logger.error("上传文件失败", error, {
                 apiPath: ctx.apiPath,
                 userId: ctx.userId,
                 roleType: ctx.roleType

package/checks/api.js

@@ -1,74 +1,51 @@
-import { Logger } from "../lib/logger.js";
-import { validateFieldRule } from "../lib/validator.js";
-import { formatValidationIssues } from "../utils/formatValidationIssues.js";
-import { isBoolean, isFunction, isLowerCamelCaseName, isPlainObject, isString } from "../utils/is.js";
-
-const apiPathRegex = /^\/api\/[a-z][a-zA-Z0-9]*(?:\/[a-z][a-zA-Z0-9]*)*$/;
-const apiKeys = new Set(["source", "type", "filePath", "relativePath", "fileName", "name", "handler", "apiPath", "method", "body", "auth", "fields", "required"]);
-
-function checkNoTrimString(issues, value, path, min = 0, max = Number.MAX_SAFE_INTEGER) {
-    if (!isString(value)) {
-        issues.push({ path: path, message: "必须是字符串" });
-        return;
-    }
-    if (value !== "" && value.trim() !== value) issues.push({ path: path, message: "不允许首尾空格" });
-    if (value.length < min) issues.push({ path: path, message: `长度不能少于${min}个字符` });
-    if (value.length > max) issues.push({ path: path, message: `长度不能超过${max}个字符` });
-}
-
-function checkApiItem(api, index) {
-    const issues = [];
-    if (!isPlainObject(api)) {
-        issues.push({ path: [index], message: "必须是对象格式" });
-        return issues;
-    }
-
-    for (const key of Object.keys(api)) {
-        if (!apiKeys.has(key)) issues.push({ path: [index, key], message: "不允许出现" });
-    }
-    for (const key of ["source", "type", "filePath", "relativePath"]) checkNoTrimString(issues, api[key], [index, key], 1);
-    checkNoTrimString(issues, api.name, [index, "name"], 1, 100);
-    if (!isString(api.fileName) || !isLowerCamelCaseName(api.fileName)) issues.push({ path: [index, "fileName"], message: "必须是 lowerCamelCase" });
-    if (!isFunction(api.handler)) issues.push({ path: [index, "handler"], message: "必须是函数" });
-    if (!isString(api.apiPath) || !apiPathRegex.test(api.apiPath)) issues.push({ path: [index, "apiPath"], message: "路径格式无效" });
-    if (!["GET", "POST", "ALL"].includes(api.method)) issues.push({ path: [index, "method"], message: "仅允许 GET|POST|ALL" });
-    if (!["none", "raw"].includes(api.body)) issues.push({ path: [index, "body"], message: "仅允许 none|raw" });
-    // body 为 raw 时不允许配置 fields/required：parser 跳过解析，参数校验由 handler 自行承担
-    if (api.body === "raw" && isPlainObject(api.fields) && Object.keys(api.fields).length > 0) {
-        issues.push({ path: [index, "body"], message: 'body 为 "raw" 时不允许配置 fields，由 handler 自行解析校验' });
-    }
-    if (api.body === "raw" && Array.isArray(api.required) && api.required.length > 0) {
-        issues.push({ path: [index, "body"], message: 'body 为 "raw" 时不允许配置 required，由 handler 自行解析校验' });
-    }
-
-    if (!isBoolean(api.auth) && (!Array.isArray(api.auth) || api.auth.length === 0 || api.auth.some((item) => !isString(item) || (item !== "" && item.trim() !== item)))) {
-        issues.push({ path: [index, "auth"], message: "必须是 boolean 或非空字符串数组" });
-    }
-
-    if (!isPlainObject(api.fields)) {
-        issues.push({ path: [index, "fields"], message: "必须是对象格式" });
-    } else {
-        for (const [fieldName, rule] of Object.entries(api.fields)) {
-            if (!isLowerCamelCaseName(fieldName)) issues.push({ path: [index, "fields", fieldName], message: "字段名必须为 lowerCamelCase" });
-            for (const issue of validateFieldRule(rule)) issues.push({ path: [index, "fields", fieldName, ...issue.path], message: issue.message });
+import { Logger } from "#befly/libs/logger/index.js";
+import { compile } from "#befly/libs/validator/index.js";
+
+import apiSchema from "../schemas/api.json";
+import { getFieldSchema } from "./field.js";
+import { formatIssues } from "./validation.js";
+
+const validate = compile(apiSchema);
+
+function checkApiRules(issues, apis) {
+    apis.forEach((api, index) => {
+        if (!api || typeof api !== "object") return;
+        const fields = api.fields || {};
+        for (const [field, definition] of Object.entries(fields)) {
+            if (!definition || typeof definition !== "object" || Array.isArray(definition) || typeof definition.name !== "string" || definition.name.length === 0) {
+                issues.push({ path: [index, "fields", field], code: "rule", message: "必须提供非空 name" });
+                continue;
+            }
+            try {
+                compile(getFieldSchema(definition));
+            } catch (error) {
+                issues.push({ path: [index, "fields", field], code: "rule", message: error.message });
+            }
         }
-    }
-
-    if (!Array.isArray(api.required) || api.required.some((item) => !isString(item) || (item !== "" && item.trim() !== item))) issues.push({ path: [index, "required"], message: "必须是字符串数组" });
-
-    return issues;
+        try {
+            compile({
+                paramType: "object",
+                fields: Object.fromEntries(Object.entries(fields).map(([field, definition]) => [field, { ...getFieldSchema(definition), optional: !(api.required || []).includes(field) }])),
+                constraints: api.constraints
+            });
+        } catch (error) {
+            issues.push({ path: [index, "constraints"], code: "rule", message: error.message });
+        }
+        for (const field of api.required || []) {
+            if (!Object.hasOwn(fields, field)) issues.push({ path: [index, "required"], code: "rule", message: `必填字段未在 fields 中声明: ${field}` });
+            else if (fields[field] && typeof fields[field] === "object" && Object.hasOwn(fields[field], "paramDefault")) issues.push({ path: [index, "required"], code: "rule", message: `必填字段不能同时配置 paramDefault: ${field}` });
+        }
+        if (api.body === "raw" && Object.keys(fields).length > 0) issues.push({ path: [index, "fields"], code: "rule", message: "body 为 raw 时不允许配置 fields" });
+        if (api.body === "raw" && (api.required || []).length > 0) issues.push({ path: [index, "required"], code: "rule", message: "body 为 raw 时不允许配置 required" });
+    });
 }
 
 export async function checkApi(apis) {
-    const issues = [];
-    if (!Array.isArray(apis)) {
-        issues.push({ path: [], message: "必须是数组" });
-    } else {
-        apis.forEach((api, index) => issues.push(...checkApiItem(api, index)));
-    }
-
+    const issues = validate(apis).issues;
+    if (Array.isArray(apis)) checkApiRules(issues, apis);
     if (issues.length === 0) return [];
-    const errors = formatValidationIssues(issues, { items: apis, itemLabel: "api" });
+
+    const errors = formatIssues(issues, { items: apis, itemLabel: "api" });
     Logger.warn("接口校验失败", { errors: errors });
     return errors;
 }

package/checks/config.js

@@ -1,18 +1,23 @@
-import { Logger } from "../lib/logger.js";
-import { validateConfig } from "../lib/validator.js";
-import { formatValidationIssues } from "../utils/formatValidationIssues.js";
+import { Logger } from "#befly/libs/logger/index.js";
+import { compile } from "#befly/libs/validator/index.js";
+
+import configSchema from "../schemas/config.json";
+import { formatIssues } from "./validation.js";
+
+const validate = compile(configSchema);
 
 export async function checkConfig(config) {
-    const issues = validateConfig(config);
+    const issues = validate(config).issues;
+    if (typeof config?.tz === "string") {
+        try {
+            new Intl.DateTimeFormat("en-US", { timeZone: config.tz }).format(0);
+        } catch {
+            issues.push({ path: ["tz"], code: "rule", message: "必须是有效 IANA 时区" });
+        }
+    }
     if (issues.length === 0) return [];
 
-    const errors = formatValidationIssues(issues, { item: config, itemLabel: "config" });
-    Logger.warn(
-        "配置校验失败",
-        {
-            errors: errors
-        },
-        false
-    );
+    const errors = formatIssues(issues, { item: config, itemLabel: "config" });
+    Logger.warn("配置校验失败", { errors: errors }, false);
     return errors;
 }

package/checks/corns.js

@@ -1,54 +1,36 @@
-import { Logger } from "../lib/logger.js";
-import { formatValidationIssues } from "../utils/formatValidationIssues.js";
-import { isFunction, isPlainObject, isValidCronSchedule } from "../utils/is.js";
+import { Logger } from "#befly/libs/logger/index.js";
+import { compile } from "#befly/libs/validator/index.js";
 
-// scanFiles 基础字段 + 定时器业务字段（schedule/handler；时区统一走 config.tz）
-const cornKeys = new Set(["source", "type", "filePath", "relativePath", "fileName", "apiPath", "schedule", "handler"]);
+import cornSchema from "../schemas/corn.json";
+import { formatIssues } from "./validation.js";
 
-export const checkCorn = (corns) => {
-    if (!Array.isArray(corns)) {
-        const errors = formatValidationIssues([{ path: [], message: "必须是数组" }], { item: corns, itemLabel: "corn" });
-        Logger.warn(`定时器校验失败`, { errors: errors });
-        return errors;
-    }
-
-    const errors = [];
-
-    // 任务名唯一性：文件名即任务名（core + app 合并后全局唯一，防止同名任务被 register 静默去重）
-    const nameMap = new Map();
-    for (const corn of corns) {
-        if (!corn?.fileName) continue;
-        nameMap.set(corn.fileName, (nameMap.get(corn.fileName) || 0) + 1);
-    }
-    const duplicateNames = [...nameMap].filter(([, count]) => count > 1).map(([name]) => name);
-    if (duplicateNames.length > 0) {
-        const duplicateCorns = corns.filter((corn) => duplicateNames.includes(corn.fileName));
-        errors.push(
-            ...formatValidationIssues(
-                duplicateCorns.map((corn, index) => ({ path: [index], message: `任务名 ${corn.fileName} 重复，请显式区分` })),
-                { items: duplicateCorns, itemLabel: "corn" }
-            )
-        );
-    }
+const validate = compile(cornSchema);
 
-    for (const [index, corn] of corns.entries()) {
-        if (!isPlainObject(corn)) {
-            errors.push(...formatValidationIssues([{ path: [index], message: "必须是对象格式" }], { items: corns, itemLabel: "corn" }));
-            continue;
-        }
+function checkCornNames(issues, corns) {
+    const counts = new Map();
+    for (const corn of corns) if (corn?.fileName) counts.set(corn.fileName, (counts.get(corn.fileName) || 0) + 1);
+    corns.forEach((corn, index) => {
+        if (corn?.fileName && counts.get(corn.fileName) > 1) issues.push({ path: [index], message: `任务名 ${corn.fileName} 重复，请显式区分` });
+    });
+}
 
-        const issues = [];
-        for (const key of Object.keys(corn)) {
-            if (!cornKeys.has(key)) issues.push({ path: [key], message: "不允许出现" });
-        }
-        if (!isFunction(corn.handler)) issues.push({ path: ["handler"], message: "必须是函数" });
-        if (!isValidCronSchedule(corn.schedule)) issues.push({ path: ["schedule"], message: "必须是可注册的 cron 表达式" });
-        if (issues.length === 0) continue;
-        errors.push(...formatValidationIssues(issues, { items: corns, itemLabel: "corn" }));
+export const checkCorn = (corns) => {
+    const issues = validate(corns).issues;
+    if (Array.isArray(corns)) {
+        checkCornNames(issues, corns);
+        corns.forEach((corn, index) => {
+            if (typeof corn?.schedule !== "string") return;
+            try {
+                const parsed = Bun.cron.parse(corn.schedule);
+                if (parsed === null) throw new TypeError("invalid cron");
+            } catch {
+                issues.push({ path: [index, "schedule"], code: "rule", message: "必须是可注册的 cron 表达式" });
+            }
+        });
     }
+    if (issues.length === 0) return [];
 
-    if (errors.length > 0) {
-        Logger.warn(`定时器校验失败`, { errors: errors });
-    }
+    const errors = formatIssues(issues, { items: corns, itemLabel: "corn" });
+    Logger.warn("定时器校验失败", { errors: errors });
     return errors;
 };

package/checks/field.js

@@ -0,0 +1,18 @@
+const SCHEMA_KEYS = ["paramType", "anyOf", "optional", "paramDefault", "enum", "minValue", "maxValue", "minItem", "maxItem", "precision", "scale", "pattern", "unique", "uniqueBy", "items", "fields", "extra", "keys", "values", "constraints"];
+
+/**
+ * 从 Core 字段定义中提取通用验证器协议，避免领域元数据进入验证器。
+ */
+export function getFieldSchema(field) {
+    if (!field || typeof field !== "object" || Array.isArray(field)) return {};
+    return Object.fromEntries(SCHEMA_KEYS.filter((key) => field[key] !== undefined).map((key) => [key, field[key]]));
+}
+
+export function getFieldErrors(issues, fields) {
+    return Object.fromEntries(
+        issues.map((issue) => {
+            const field = issue.path[0];
+            return [field, `${fields[field]?.name || field}${issue.message}`];
+        })
+    );
+}

package/checks/items.js

@@ -1,67 +1,23 @@
-import { Logger } from "../lib/logger.js";
-import { formatValidationIssues } from "../utils/formatValidationIssues.js";
-import { isFunction, isFiniteNumber, isPlainObject, isString } from "../utils/is.js";
+import { Logger } from "#befly/libs/logger/index.js";
+import { compile } from "#befly/libs/validator/index.js";
 
-const itemKeys = new Set(["source", "type", "filePath", "relativePath", "fileName", "apiPath", "handler", "order"]);
+import itemSchema from "../schemas/item.json";
+import { formatIssues } from "./validation.js";
 
-function checkItem(item) {
-    const issues = [];
-    if (!isPlainObject(item)) {
-        issues.push({ path: [], message: "必须是对象格式" });
-        return issues;
-    }
-
-    for (const key of Object.keys(item)) {
-        if (!itemKeys.has(key)) issues.push({ path: [key], message: "不允许出现" });
-    }
-    for (const key of ["source", "type", "filePath", "relativePath", "fileName", "apiPath"]) {
-        if (!isString(item[key]) || item[key].length === 0 || item[key].trim() !== item[key]) issues.push({ path: [key], message: "必须是非空且无首尾空格的字符串" });
-    }
-    if (!isFunction(item.handler)) issues.push({ path: ["handler"], message: "必须是函数" });
-    if (!isFiniteNumber(item.order)) issues.push({ path: ["order"], message: "必须是有限数字" });
-    // 非核心（app）插件/钩子的 order 必须大于 1000，避免与核心区间（10~90）撞号
-    if (item.source === "app" && isFiniteNumber(item.order) && item.order <= 1000) issues.push({ path: ["order"], message: "非核心插件/钩子 order 必须大于 1000" });
-    return issues;
-}
-
-function checkItemList(items, label, labelEn) {
-    if (!Array.isArray(items)) {
-        const errors = formatValidationIssues([{ path: [], message: "必须是数组" }], { item: items, itemLabel: labelEn });
-        Logger.warn(`${label}校验失败`, { errors: errors });
-        return errors;
-    }
+const validate = compile(itemSchema);
 
-    const errors = [];
-
-    // order 冲突校验：同 order 的执行顺序依赖扫描顺序，要求显式区分
-    const orderMap = new Map();
-    for (const item of items) {
-        if (!isFiniteNumber(item.order)) continue;
-        orderMap.set(item.order, (orderMap.get(item.order) || 0) + 1);
-    }
-    const duplicateOrders = [...orderMap].filter(([, count]) => count > 1).map(([order]) => order);
-    if (duplicateOrders.length > 0) {
-        const duplicateItems = items.filter((item) => duplicateOrders.includes(item.order));
-        errors.push(
-            ...formatValidationIssues(
-                duplicateItems.map((item, index) => ({ path: [index], message: `order ${item.order} 重复，请显式区分` })),
-                { items: duplicateItems, itemLabel: labelEn }
-            )
-        );
-    }
-
-    for (const item of items) {
-        const issues = checkItem(item);
-        if (issues.length === 0) continue;
-        errors.push(...formatValidationIssues(issues, { item: item, itemLabel: labelEn }));
-    }
-
-    if (errors.length > 0) {
-        Logger.warn(`${label}校验失败`, { errors: errors });
+function checkItems(items, label, labelEn) {
+    const issues = validate(items).issues;
+    if (Array.isArray(items)) {
+        items.forEach((item, index) => {
+            if (item?.source === "app" && typeof item.order === "number" && item.order <= 1000) issues.push({ path: [index, "order"], code: "rule", message: "非核心插件/钩子 order 必须大于 1000" });
+        });
     }
+    if (issues.length === 0) return [];
+    const errors = formatIssues(issues, { items: items, itemLabel: labelEn });
+    Logger.warn(`${label}校验失败`, { errors: errors });
     return errors;
 }
 
-export const checkHook = (hooks) => checkItemList(hooks, "钩子", "hook");
-
-export const checkPlugin = (plugins) => checkItemList(plugins, "插件", "plugin");
+export const checkHook = (hooks) => checkItems(hooks, "钩子", "hook");
+export const checkPlugin = (plugins) => checkItems(plugins, "插件", "plugin");