befly 3.15.19 → 3.15.21

package/dist/befly.js

@@ -913,11 +913,29 @@ function buildLogLine(level, record) {
     hostname: HOSTNAME
   };
   if (record && isPlainObject(record)) {
-    const out = Object.assign({}, record, base);
+    const out = {};
+    out["level"] = base["level"];
+    out["time"] = base["time"];
+    out["timeFormat"] = base["timeFormat"];
+    out["pid"] = base["pid"];
+    out["hostname"] = base["hostname"];
+    for (const key of Object.keys(record)) {
+      if (key === "level")
+        continue;
+      if (key === "time")
+        continue;
+      if (key === "timeFormat")
+        continue;
+      if (key === "pid")
+        continue;
+      if (key === "hostname")
+        continue;
+      out[key] = record[key];
+    }
     if (record.msg !== undefined) {
-      out.msg = record.msg;
-    } else if (out.msg === undefined) {
-      out.msg = "";
+      out["msg"] = record.msg;
+    } else if (out["msg"] === undefined) {
+      out["msg"] = "";
     }
     return `${safeJsonStringify(out)}
 `;
@@ -7727,6 +7745,38 @@ async function loadBeflyConfig(nodeEnv) {
 
 // checks/checkApi.ts
 init_logger();
+
+// types/coreError.ts
+class CoreError extends Error {
+  kind;
+  code;
+  meta;
+  noLog;
+  logged;
+  cause;
+  constructor(options) {
+    super(options.message);
+    this.name = "CoreError";
+    this.kind = options.kind;
+    this.code = typeof options.code === "string" && options.code.length > 0 ? options.code : null;
+    this.meta = options.meta ? options.meta : null;
+    this.noLog = options.noLog === true;
+    this.logged = options.logged === true;
+    this.cause = options.cause;
+  }
+}
+function isCoreError(error) {
+  if (typeof error !== "object" || error === null)
+    return false;
+  const anyErr = error;
+  if (anyErr.name !== "CoreError")
+    return false;
+  if (typeof anyErr.kind !== "string")
+    return false;
+  return true;
+}
+
+// checks/checkApi.ts
 init_util();
 async function checkApi(apis) {
   let hasError = false;
@@ -7831,7 +7881,15 @@ async function checkApi(apis) {
     }
   }
   if (hasError) {
-    throw new Error("\u63A5\u53E3\u7ED3\u6784\u68C0\u67E5\u5931\u8D25");
+    throw new CoreError({
+      kind: "policy",
+      message: "\u63A5\u53E3\u7ED3\u6784\u68C0\u67E5\u5931\u8D25",
+      logged: true,
+      meta: {
+        subsystem: "checks",
+        operation: "checkApi"
+      }
+    });
   }
 }
 
@@ -8067,7 +8125,15 @@ async function checkHook(hooks) {
     }
   }
   if (hasError) {
-    throw new Error("\u94A9\u5B50\u7ED3\u6784\u68C0\u67E5\u5931\u8D25");
+    throw new CoreError({
+      kind: "policy",
+      message: "\u94A9\u5B50\u7ED3\u6784\u68C0\u67E5\u5931\u8D25",
+      logged: true,
+      meta: {
+        subsystem: "checks",
+        operation: "checkHook"
+      }
+    });
   }
 }
 
@@ -8285,7 +8351,15 @@ async function checkPlugin(plugins) {
     }
   }
   if (hasError) {
-    throw new Error("\u63D2\u4EF6\u7ED3\u6784\u68C0\u67E5\u5931\u8D25");
+    throw new CoreError({
+      kind: "policy",
+      message: "\u63D2\u4EF6\u7ED3\u6784\u68C0\u67E5\u5931\u8D25",
+      logged: true,
+      meta: {
+        subsystem: "checks",
+        operation: "checkPlugin"
+      }
+    });
   }
 }
 
@@ -8614,13 +8688,21 @@ async function checkTable(tables, config2) {
     }
   }
   if (hasError) {
-    throw new Error("\u8868\u7ED3\u6784\u68C0\u67E5\u5931\u8D25");
+    throw new CoreError({
+      kind: "policy",
+      message: "\u8868\u7ED3\u6784\u68C0\u67E5\u5931\u8D25",
+      logged: true,
+      meta: {
+        subsystem: "checks",
+        operation: "checkTable"
+      }
+    });
   }
 }
 
 // lib/connect.ts
-init_logger();
 var {SQL, RedisClient } = globalThis.Bun;
+init_logger();
 
 class Connect {
   static sqlClient = null;
@@ -8638,16 +8720,16 @@ class Connect {
     const password = config2.password === undefined ? "" : typeof config2.password === "string" ? config2.password : "";
     const database = typeof config2.database === "string" ? config2.database.trim() : "";
     if (!host) {
-      throw new Error("\u6570\u636E\u5E93\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1Adb.host \u7F3A\u5931");
+      throw new CoreError({ message: "\u6570\u636E\u5E93\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1Adb.host \u7F3A\u5931", kind: "validation" });
     }
     if (!Number.isFinite(port) || port < 1 || port > 65535) {
-      throw new Error(`\u6570\u636E\u5E93\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1Adb.port \u975E\u6CD5\uFF08\u5F53\u524D\u503C\uFF1A${String(config2.port)}\uFF09`);
+      throw new CoreError({ message: `\u6570\u636E\u5E93\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1Adb.port \u975E\u6CD5\uFF08\u5F53\u524D\u503C\uFF1A${String(config2.port)}\uFF09`, kind: "validation" });
     }
     if (!username) {
-      throw new Error("\u6570\u636E\u5E93\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1Adb.username \u7F3A\u5931");
+      throw new CoreError({ message: "\u6570\u636E\u5E93\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1Adb.username \u7F3A\u5931", kind: "validation" });
     }
     if (!database) {
-      throw new Error("\u6570\u636E\u5E93\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1Adb.database \u7F3A\u5931");
+      throw new CoreError({ message: "\u6570\u636E\u5E93\u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1Adb.database \u7F3A\u5931", kind: "validation" });
     }
     const user = encodeURIComponent(username);
     const pass = encodeURIComponent(password);
@@ -8666,10 +8748,10 @@ class Connect {
         const majorText = versionText.split(".")[0];
         const major = Number(majorText);
         if (!Number.isFinite(major)) {
-          throw new Error(`\u65E0\u6CD5\u89E3\u6790 MySQL \u7248\u672C\u4FE1\u606F: ${versionText}`);
+          throw new CoreError({ message: `\u65E0\u6CD5\u89E3\u6790 MySQL \u7248\u672C\u4FE1\u606F: ${versionText}`, kind: "runtime", meta: { subsystem: "sql", operation: "version" } });
         }
         if (major < 8) {
-          throw new Error(`\u4EC5\u652F\u6301 MySQL 8.0+\uFF0C\u5F53\u524D\u7248\u672C\uFF1A${versionText}`);
+          throw new CoreError({ message: `\u4EC5\u652F\u6301 MySQL 8.0+\uFF0C\u5F53\u524D\u7248\u672C\uFF1A${versionText}`, kind: "policy", meta: { subsystem: "sql", operation: "version" } });
         }
         this.mysqlVersionText = versionText;
         this.mysqlVersionMajor = major;
@@ -8690,7 +8772,21 @@ class Connect {
       try {
         await sql?.close();
       } catch {}
-      throw error;
+      if (isCoreError(error)) {
+        error.logged = true;
+        throw error;
+      }
+      const msg = `SQL \u8FDE\u63A5\u5931\u8D25: ${error && typeof error.message === "string" ? error.message : String(error)}`;
+      throw new CoreError({
+        message: msg,
+        kind: "runtime",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "sql",
+          operation: "connect"
+        }
+      });
     }
   }
   static async disconnectSql() {
@@ -8741,7 +8837,17 @@ class Connect {
       return redis;
     } catch (error) {
       Logger.error({ err: error, msg: "[Connect] Redis \u8FDE\u63A5\u5931\u8D25" });
-      throw new Error(`Redis \u8FDE\u63A5\u5931\u8D25: ${error.message}`);
+      const msg = `Redis \u8FDE\u63A5\u5931\u8D25: ${error && typeof error.message === "string" ? error.message : String(error)}`;
+      throw new CoreError({
+        message: msg,
+        kind: "runtime",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "redis",
+          operation: "connect"
+        }
+      });
     }
   }
   static async disconnectRedis() {
@@ -8769,7 +8875,21 @@ class Connect {
       const env = typeof process?.env?.NODE_ENV === "string" ? "development" : "";
       Logger.error({ env, err: error, msg: "\u6570\u636E\u5E93\u8FDE\u63A5\u521D\u59CB\u5316\u5931\u8D25" });
       await this.disconnect();
-      throw error;
+      if (isCoreError(error)) {
+        error.logged = true;
+        throw error;
+      }
+      const msg = `\u6570\u636E\u5E93\u8FDE\u63A5\u521D\u59CB\u5316\u5931\u8D25: ${error && typeof error.message === "string" ? error.message : String(error)}`;
+      throw new CoreError({
+        message: msg,
+        kind: "runtime",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "connect",
+          operation: "connect"
+        }
+      });
     }
   }
   static async disconnect() {
@@ -8863,7 +8983,18 @@ async function loadApis(apis) {
       apisMap.set(path, route);
     } catch (error) {
       Logger.error({ err: error, api: api.relativePath, file: api.filePath, msg: "\u63A5\u53E3\u52A0\u8F7D\u5931\u8D25" });
-      throw error;
+      throw new CoreError({
+        kind: "runtime",
+        message: "\u63A5\u53E3\u52A0\u8F7D\u5931\u8D25",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "api",
+          operation: "load",
+          relativePath: api.relativePath,
+          filePath: api.filePath
+        }
+      });
     }
   }
   return apisMap;
@@ -8979,7 +9110,7 @@ async function loadHooks(hooks) {
   });
   const sortedHooks = sortModules(enabledHooks, { moduleLabel: "\u94A9\u5B50" });
   if (sortedHooks === false) {
-    throw new Error("\u94A9\u5B50\u4F9D\u8D56\u5173\u7CFB\u9519\u8BEF");
+    throw new CoreError({ message: "\u94A9\u5B50\u4F9D\u8D56\u5173\u7CFB\u9519\u8BEF", kind: "policy", logged: true });
   }
   for (const item of sortedHooks) {
     const hookName = item.moduleName;
@@ -9017,7 +9148,7 @@ async function loadPlugins(plugins, context) {
   });
   const sortedPlugins = sortModules(enabledPlugins, { moduleLabel: "\u63D2\u4EF6" });
   if (sortedPlugins === false) {
-    throw new Error("\u63D2\u4EF6\u4F9D\u8D56\u5173\u7CFB\u9519\u8BEF");
+    throw new CoreError({ message: "\u63D2\u4EF6\u4F9D\u8D56\u5173\u7CFB\u9519\u8BEF", kind: "policy", logged: true });
   }
   for (const item of sortedPlugins) {
     const pluginName = item.moduleName;
@@ -9039,7 +9170,17 @@ async function loadPlugins(plugins, context) {
       });
     } catch (error) {
       Logger.error({ err: error, plugin: pluginName, msg: "\u63D2\u4EF6\u521D\u59CB\u5316\u5931\u8D25" });
-      throw error;
+      throw new CoreError({
+        kind: "runtime",
+        message: `\u63D2\u4EF6\u521D\u59CB\u5316\u5931\u8D25: ${pluginName}`,
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "plugin",
+          operation: "init",
+          plugin: pluginName
+        }
+      });
     }
   }
   return pluginsMap;
@@ -9327,10 +9468,10 @@ var getApiParentPath = (apiPath) => {
 async function syncApi(ctx, apis) {
   const tableName = "addon_admin_api";
   if (!ctx.db) {
-    throw new Error("\u540C\u6B65\u63A5\u53E3\uFF1Actx.db \u672A\u521D\u59CB\u5316");
+    throw new CoreError({ message: "\u540C\u6B65\u63A5\u53E3\uFF1Actx.db \u672A\u521D\u59CB\u5316", kind: "validation" });
   }
   if (!ctx.cache) {
-    throw new Error("\u540C\u6B65\u63A5\u53E3\uFF1Actx.cache \u672A\u521D\u59CB\u5316");
+    throw new CoreError({ message: "\u540C\u6B65\u63A5\u53E3\uFF1Actx.cache \u672A\u521D\u59CB\u5316", kind: "validation" });
   }
   if (!(await ctx.db.tableExists(tableName)).data) {
     Logger.debug(`${tableName} \u8868\u4E0D\u5B58\u5728`);
@@ -9439,7 +9580,7 @@ async function syncApi(ctx, apis) {
 // sync/syncCache.ts
 async function syncCache(ctx) {
   if (!ctx.cache) {
-    throw new Error("\u540C\u6B65\u7F13\u5B58\uFF1Actx.cache \u672A\u521D\u59CB\u5316");
+    throw new CoreError({ message: "\u540C\u6B65\u7F13\u5B58\uFF1Actx.cache \u672A\u521D\u59CB\u5316", kind: "validation" });
   }
   await ctx.cache.cacheApis();
   await ctx.cache.cacheMenus();
@@ -9827,13 +9968,13 @@ function flattenMenusToDefMap(mergedMenus) {
 }
 async function syncMenu(ctx, mergedMenus) {
   if (!ctx.db) {
-    throw new Error("\u540C\u6B65\u83DC\u5355\uFF1Actx.db \u672A\u521D\u59CB\u5316");
+    throw new CoreError({ message: "\u540C\u6B65\u83DC\u5355\uFF1Actx.db \u672A\u521D\u59CB\u5316", kind: "validation" });
   }
   if (!ctx.cache) {
-    throw new Error("\u540C\u6B65\u83DC\u5355\uFF1Actx.cache \u672A\u521D\u59CB\u5316");
+    throw new CoreError({ message: "\u540C\u6B65\u83DC\u5355\uFF1Actx.cache \u672A\u521D\u59CB\u5316", kind: "validation" });
   }
   if (!ctx.config) {
-    throw new Error("\u540C\u6B65\u83DC\u5355\uFF1Actx.config \u672A\u521D\u59CB\u5316");
+    throw new CoreError({ message: "\u540C\u6B65\u83DC\u5355\uFF1Actx.config \u672A\u521D\u59CB\u5316", kind: "validation" });
   }
   if (!(await ctx.db.tableExists("addon_admin_menu")).data) {
     Logger.debug(`addon_admin_menu \u8868\u4E0D\u5B58\u5728`);
@@ -10227,6 +10368,8 @@ class SyncTable {
         throw new Error("\u540C\u6B65\u8868\uFF1A\u8BF7\u4F20\u5165\u591A\u4E2A\u8868\u5B9A\u4E49\u7EC4\u6210\u7684\u6570\u7EC4");
       }
       await SyncTable.ensureDbVersion(this.db);
+      const tableTasks = [];
+      const incompatibleTypeChanges = [];
       for (const item of items) {
         if (!item || item.type !== "table") {
           continue;
@@ -10237,9 +10380,100 @@ class SyncTable {
           SyncTable.normalizeFieldDefinitionInPlace(fieldDef);
         }
         const existsTable = await SyncTable.tableExists(this.db, this.dbName, tableName);
+        const task = {
+          item,
+          tableName,
+          tableFields,
+          existsTable,
+          existingColumns: null,
+          existingIndexes: null,
+          plan: null,
+          planSummary: null,
+          planDetails: null
+        };
+        if (existsTable) {
+          const existingColumns = await SyncTable.getTableColumns(this.db, this.dbName, tableName);
+          const existingIndexes = await SyncTable.getTableIndexes(this.db, this.dbName, tableName);
+          const changes = SyncTable.collectIncompatibleTypeChanges(tableName, existingColumns, tableFields);
+          for (const change of changes) {
+            incompatibleTypeChanges.push(change);
+          }
+          task.existingColumns = existingColumns;
+          task.existingIndexes = existingIndexes;
+        }
+        tableTasks.push(task);
+      }
+      if (incompatibleTypeChanges.length > 0) {
+        const lines = [];
+        for (const change of incompatibleTypeChanges) {
+          lines.push(`- ${change.tableName}.${change.dbFieldName}: ${change.currentType} -> ${change.expectedType}`);
+        }
+        const msgLines = [];
+        msgLines.push("\u7981\u6B62\u5B57\u6BB5\u7C7B\u578B\u53D8\u66F4\uFF08\u68C0\u6D4B\u5230\u4E0D\u517C\u5BB9/\u6536\u7F29\u53D8\u66F4\uFF09:");
+        for (const line of lines) {
+          msgLines.push(line);
+        }
+        msgLines.push("\u8BF4\u660E: \u4EC5\u5141\u8BB8\u540C\u7C7B\u578B\u7684\u5BBD\u5316\u53D8\u66F4\uFF08\u5982 TINYINT->SMALLINT->INT->BIGINT\uFF09\uFF0C\u4EE5\u53CA\u90E8\u5206\u517C\u5BB9\u53D8\u66F4\uFF08\u5982 VARCHAR->TEXT\u3001CHAR/VARCHAR \u4E92\u8F6C\u3001float->double\uFF09\u3002");
+        msgLines.push("\u63D0\u793A: \u82E5\u786E\u9700\u6536\u7F29\uFF0C\u8BF7\u5148\u624B\u5DE5\u8FC1\u79FB/\u6E05\u6D17\u6570\u636E\u540E\u518D\u6267\u884C\u540C\u6B65\u3002");
+        const err = new Error(msgLines.join(`
+`));
+        err.__syncTableNoLog = true;
+        throw err;
+      }
+      for (const task of tableTasks) {
+        if (!task.existsTable) {
+          continue;
+        }
+        if (!task.existingColumns || !task.existingIndexes) {
+          throw new Error(`\u540C\u6B65\u8868\uFF1A\u5185\u90E8\u9519\u8BEF\uFF1A\u9884\u68C0\u9636\u6BB5\u7F3A\u5931\u8868\u5143\u4FE1\u606F\uFF08\u8868=${task.tableName}\uFF09`);
+        }
+        const built = SyncTable.buildTablePlan({
+          tableName: task.tableName,
+          fields: task.tableFields,
+          existingColumns: task.existingColumns,
+          existingIndexes: task.existingIndexes
+        });
+        task.plan = built.plan;
+        task.planSummary = built.summary;
+        task.planDetails = built.details;
+      }
+      for (const task of tableTasks) {
+        const item = task.item;
+        const tableName = task.tableName;
+        const tableFields = task.tableFields;
+        const existsTable = task.existsTable;
         try {
           if (existsTable) {
-            await SyncTable.modifyTable(this.db, this.dbName, tableName, tableFields);
+            const plan = task.plan;
+            const summary = task.planSummary;
+            const details = task.planDetails;
+            if (plan && plan.changed && summary && details) {
+              const msg = `[\u8868 ${tableName}] \u53D8\u66F4\u6C47\u603B\uFF0C\u65B0\u589E\u5B57\u6BB5=${summary.addedBusiness}\uFF0C\u65B0\u589E\u7CFB\u7EDF\u5B57\u6BB5=${summary.addedSystem}\uFF0C\u4FEE\u6539\u5B57\u6BB5=${summary.modified}\uFF0C\u7D22\u5F15\u53D8\u66F4=${summary.indexChanges}`;
+              const detailLines = details.fieldChanges.flatMap((d) => d.changes.map((change) => {
+                const current = String(change.current ?? "");
+                const expected = String(change.expected ?? "");
+                return `- ${d.dbFieldName}.${change.type}: ${current} -> ${expected}`;
+              }));
+              const indexLines = details.indexChanges.map((change) => {
+                const indexLabel = `idx_${change.fieldName}` === change.indexName ? change.indexName : change.indexName;
+                if (change.action === "create") {
+                  return `- index.${indexLabel}: \u65E0 -> ${change.indexName}(${change.fieldName})`;
+                }
+                return `- index.${indexLabel}: ${change.indexName}(${change.fieldName}) -> \u65E0`;
+              });
+              const allLines = [];
+              for (const line of detailLines) {
+                allLines.push(line);
+              }
+              for (const line of indexLines) {
+                allLines.push(line);
+              }
+              Logger.debug(msg);
+              for (const line of allLines) {
+                Logger.debug(`[\u8868 ${tableName}] \u53D8\u66F4\u660E\u7EC6 ${line}`);
+              }
+              await SyncTable.applyTablePlan(this.db, tableName, plan);
+            }
           } else {
             await SyncTable.createTable(this.db, tableName, tableFields);
           }
@@ -10268,6 +10502,9 @@ class SyncTable {
       if (error?.__syncTableLogged === true) {
         throw error;
       }
+      if (error?.__syncTableNoLog === true) {
+        throw error;
+      }
       const errMsg = String(error?.message || error);
       const sqlInfo = error?.sqlInfo;
       Logger.error({
@@ -10594,6 +10831,32 @@ class SyncTable {
       throw new Error([`\u7981\u6B62\u5B57\u6BB5\u7C7B\u578B\u53D8\u66F4: ${tableName}.${dbFieldName}`, `\u5F53\u524D\u7C7B\u578B: ${typeChange.current}`, `\u76EE\u6807\u7C7B\u578B: ${typeChange.expected}`, "\u8BF4\u660E: \u4EC5\u5141\u8BB8\u5BBD\u5316\u578B\u53D8\u66F4\uFF08\u5982 INT->BIGINT, VARCHAR->TEXT\uFF09\uFF0C\u4EE5\u53CA CHAR/VARCHAR \u4E92\u8F6C\uFF1BDATETIME \u4E0E BIGINT \u4E0D\u5141\u8BB8\u4E92\u8F6C\uFF08\u9700\u8981\u624B\u52A8\u8FC1\u79FB\u6570\u636E\uFF09"].join(`
 `));
   }
+  static collectIncompatibleTypeChanges(tableName, existingColumns, fields) {
+    const out = [];
+    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
+      const dbFieldName = snakeCase(fieldKey);
+      const existing = existingColumns[dbFieldName];
+      if (!existing)
+        continue;
+      const comparison = SyncTable.compareFieldDefinition(existing, fieldDef);
+      const typeChange = comparison.find((c) => c.type === "datatype");
+      if (!typeChange)
+        continue;
+      const currentType = String(typeChange.current || "").toLowerCase();
+      const expectedType = String(typeChange.expected || "").toLowerCase();
+      const currentBase = currentType.replace(/\s*unsigned/gi, "").replace(/\([^)]*\)/g, "").trim();
+      const expectedBase = expectedType.replace(/\s*unsigned/gi, "").replace(/\([^)]*\)/g, "").trim();
+      if (currentBase !== expectedBase && !SyncTable.isCompatibleTypeChange(currentType, expectedType)) {
+        out.push({
+          tableName,
+          dbFieldName,
+          currentType: String(typeChange.current ?? ""),
+          expectedType: String(typeChange.expected ?? "")
+        });
+      }
+    }
+    return out;
+  }
   static truncateForLog(input, maxLen) {
     const s = String(input);
     if (maxLen <= 0)
@@ -13216,7 +13479,16 @@ class CacheHelper {
       }
     } catch (error) {
       Logger.error({ err: error, msg: "\u26A0\uFE0F \u89D2\u8272\u6743\u9650\u7F13\u5B58\u5F02\u5E38\uFF08\u5C06\u963B\u65AD\u542F\u52A8\uFF09" });
-      throw error;
+      throw new CoreError({
+        kind: "runtime",
+        message: "\u26A0\uFE0F \u89D2\u8272\u6743\u9650\u7F13\u5B58\u5F02\u5E38\uFF08\u5C06\u963B\u65AD\u542F\u52A8\uFF09",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "cache",
+          operation: "rebuildRoleApiPermissions"
+        }
+      });
     }
   }
   async refreshRoleApiPermissions(roleCode, apiPaths) {
@@ -13301,10 +13573,10 @@ var cachePlugin = {
   deps: ["logger", "redis", "db"],
   async handler(befly) {
     if (!befly.db) {
-      throw new Error("\u7F13\u5B58\u521D\u59CB\u5316\u5931\u8D25\uFF1Actx.db \u672A\u521D\u59CB\u5316");
+      throw new CoreError({ message: "\u7F13\u5B58\u521D\u59CB\u5316\u5931\u8D25\uFF1Actx.db \u672A\u521D\u59CB\u5316", kind: "validation" });
     }
     if (!befly.redis) {
-      throw new Error("\u7F13\u5B58\u521D\u59CB\u5316\u5931\u8D25\uFF1Actx.redis \u672A\u521D\u59CB\u5316");
+      throw new CoreError({ message: "\u7F13\u5B58\u521D\u59CB\u5316\u5931\u8D25\uFF1Actx.redis \u672A\u521D\u59CB\u5316", kind: "validation" });
     }
     return new CacheHelper({ db: befly.db, redis: befly.redis });
   }
@@ -15092,7 +15364,20 @@ class DbHelper {
         fields: insertFields,
         msg: "\u6279\u91CF\u63D2\u5165\u5931\u8D25"
       });
-      throw error;
+      throw new CoreError({
+        kind: "runtime",
+        message: "\u6279\u91CF\u63D2\u5165\u5931\u8D25",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "sql",
+          operation: "insBatch",
+          table,
+          snakeTable,
+          count: dataList.length,
+          fields: insertFields
+        }
+      });
     }
   }
   async delForceBatch(table, ids) {
@@ -15370,10 +15655,10 @@ var dbPlugin = {
     const env = befly.config?.nodeEnv;
     const dbName = String(befly.config?.db?.database || "");
     if (!dbName) {
-      throw new Error("\u6570\u636E\u5E93\u521D\u59CB\u5316\u5931\u8D25\uFF1Abefly.config.db.database \u7F3A\u5931");
+      throw new CoreError({ message: "\u6570\u636E\u5E93\u521D\u59CB\u5316\u5931\u8D25\uFF1Abefly.config.db.database \u7F3A\u5931", kind: "validation" });
     }
     if (!befly.redis) {
-      throw new Error("Redis \u672A\u521D\u59CB\u5316");
+      throw new CoreError({ message: "Redis \u672A\u521D\u59CB\u5316", kind: "validation" });
     }
     try {
       const sql = Connect.getSql();
@@ -15383,7 +15668,16 @@ var dbPlugin = {
       return dbManager;
     } catch (error) {
       Logger.error({ env, err: error, msg: "\u6570\u636E\u5E93\u521D\u59CB\u5316\u5931\u8D25" });
-      throw error;
+      throw new CoreError({
+        kind: "runtime",
+        message: "\u6570\u636E\u5E93\u521D\u59CB\u5316\u5931\u8D25",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "db",
+          operation: "init"
+        }
+      });
     }
   }
 };
@@ -15853,7 +16147,16 @@ class RedisHelper {
       return res;
     } catch (error) {
       Logger.error({ err: error, msg: "Redis ping \u9519\u8BEF" });
-      throw error;
+      throw new CoreError({
+        kind: "runtime",
+        message: "Redis ping \u9519\u8BEF",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "redis",
+          operation: "ping"
+        }
+      });
     }
   }
 }
@@ -15871,7 +16174,16 @@ var redisPlugin = {
       return new RedisHelper(redisPrefix);
     } catch (error) {
       Logger.error({ env, err: error, msg: "Redis \u521D\u59CB\u5316\u5931\u8D25" });
-      throw error;
+      throw new CoreError({
+        kind: "runtime",
+        message: "Redis \u521D\u59CB\u5316\u5931\u8D25",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "redis",
+          operation: "init"
+        }
+      });
     }
   }
 };
@@ -16221,7 +16533,49 @@ class Befly {
       Logger.info(`\u670D\u52A1\u5668\u76D1\u542C\u5730\u5740: ${server.url}`);
       return server;
     } catch (error) {
-      Logger.error({ err: error, msg: "\u9879\u76EE\u542F\u52A8\u5931\u8D25" });
+      const errMessage = error instanceof Error ? error.message : String(error);
+      let kind = "runtime";
+      let alreadyLogged = false;
+      let noLog = false;
+      if (isCoreError(error)) {
+        kind = error.kind;
+        alreadyLogged = error.logged === true;
+        noLog = error.noLog === true;
+      } else {
+        const anyErr = error;
+        if (anyErr && anyErr.__syncTableLogged === true) {
+          alreadyLogged = true;
+        }
+        if (anyErr && anyErr.__syncTableNoLog === true) {
+          kind = "policy";
+        }
+        if (anyErr && anyErr.__coreLogged === true) {
+          alreadyLogged = true;
+        }
+        if (anyErr && anyErr.__coreNoLog === true) {
+          noLog = true;
+        }
+      }
+      if (alreadyLogged) {
+        Logger.error({
+          msg: "\u9879\u76EE\u542F\u52A8\u5931\u8D25\uFF08\u4E0B\u5C42\u5DF2\u8BB0\u5F55\uFF09",
+          errorKind: kind,
+          errorMessage: errMessage
+        });
+      } else if (noLog) {
+        Logger.error({
+          msg: "\u9879\u76EE\u542F\u52A8\u5931\u8D25",
+          errorKind: kind,
+          errorMessage: errMessage
+        });
+      } else {
+        Logger.error({
+          msg: "\u9879\u76EE\u542F\u52A8\u5931\u8D25",
+          errorKind: kind,
+          errorMessage: errMessage,
+          err: error
+        });
+      }
       try {
         await Logger.flush();
       } catch {}