befly 3.16.4 → 3.16.6

package/dist/befly.js

@@ -9833,6 +9833,7 @@ async function syncCache(ctx) {
   await ctx.cache.cacheApis();
   await ctx.cache.cacheMenus();
   await ctx.cache.rebuildRoleApiPermissions();
+  await ctx.cache.rebuildRoleMenuPermissions();
 }
 
 // lib/cipher.ts
@@ -11482,32 +11483,6 @@ var calcPerfTime = (startTime, endTime = Bun.nanoseconds()) => {
   }
 };
 
-// utils/processInfo.ts
-function getProcessRole(env) {
-  const runtimeEnv = env || {};
-  const bunWorkerId = runtimeEnv["BUN_WORKER_ID"];
-  const pm2InstanceId = runtimeEnv["PM2_INSTANCE_ID"];
-  if (bunWorkerId !== undefined) {
-    return {
-      role: bunWorkerId === "" ? "primary" : "worker",
-      instanceId: bunWorkerId || "0",
-      env: "bun-cluster"
-    };
-  }
-  if (pm2InstanceId !== undefined) {
-    return {
-      role: pm2InstanceId === "0" ? "primary" : "worker",
-      instanceId: pm2InstanceId,
-      env: "pm2-cluster"
-    };
-  }
-  return {
-    role: "primary",
-    instanceId: null,
-    env: "standalone"
-  };
-}
-
 // utils/scanSources.ts
 init_dist();
 
@@ -13109,6 +13084,9 @@ class CacheKeys {
   static roleInfo(roleCode) {
     return `role:info:${roleCode}`;
   }
+  static roleMenus(roleCode) {
+    return `role:menus:${roleCode}`;
+  }
   static roleApis(roleCode) {
     return `role:apis:${roleCode}`;
   }
@@ -13694,6 +13672,25 @@ class CacheHelper {
     }
     return trimmed;
   }
+  assertMenuPathname(value, errorPrefix) {
+    if (typeof value !== "string") {
+      throw new Error(`${errorPrefix} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new Error(`${errorPrefix} \u4E0D\u5141\u8BB8\u4E3A\u7A7A\u5B57\u7B26\u4E32`);
+    }
+    if (!trimmed.startsWith("/")) {
+      throw new Error(`${errorPrefix} \u5FC5\u987B\u662F pathname\uFF08\u4EE5 / \u5F00\u5934\uFF09`);
+    }
+    if (trimmed.includes(" ")) {
+      throw new Error(`${errorPrefix} \u4E0D\u5141\u8BB8\u5305\u542B\u7A7A\u683C`);
+    }
+    if (trimmed.length > 1 && trimmed.endsWith("/")) {
+      throw new Error(`${errorPrefix} \u4E0D\u5141\u8BB8\u4EE5 / \u7ED3\u5C3E`);
+    }
+    return trimmed;
+  }
   assertApiPathList(value, roleCode) {
     if (value === null || value === undefined)
       return [];
@@ -13721,6 +13718,33 @@ class CacheHelper {
     }
     return out;
   }
+  assertMenuPathList(value, roleCode) {
+    if (value === null || value === undefined)
+      return [];
+    let list = value;
+    if (typeof list === "string") {
+      const trimmed = list.trim();
+      if (trimmed === "" || trimmed === "null") {
+        return [];
+      }
+      if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+          list = JSON.parse(trimmed);
+        } catch {
+          throw new Error(`\u89D2\u8272\u83DC\u5355\u6743\u9650\u6570\u636E\u4E0D\u5408\u6CD5\uFF1Aaddon_admin_role.menus JSON \u89E3\u6790\u5931\u8D25\uFF0CroleCode=${roleCode}`);
+        }
+      }
+    }
+    if (!Array.isArray(list)) {
+      const typeLabel = typeof list;
+      throw new Error(`\u89D2\u8272\u83DC\u5355\u6743\u9650\u6570\u636E\u4E0D\u5408\u6CD5\uFF1Aaddon_admin_role.menus \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\u6216 JSON \u6570\u7EC4\u5B57\u7B26\u4E32\uFF0CroleCode=${roleCode}\uFF0Ctype=${typeLabel}`);
+    }
+    const out = [];
+    for (const item of list) {
+      out.push(this.assertMenuPathname(item, `\u89D2\u8272\u83DC\u5355\u6743\u9650\u6570\u636E\u4E0D\u5408\u6CD5\uFF1Aaddon_admin_role.menus \u5143\u7D20\uFF0CroleCode=${roleCode}`));
+    }
+    return out;
+  }
   async cacheApis() {
     try {
       const tableExists = await this.db.tableExists("addon_admin_api");
@@ -13807,6 +13831,56 @@ class CacheHelper {
       });
     }
   }
+  async rebuildRoleMenuPermissions() {
+    try {
+      const roleTableExists = await this.db.tableExists("addon_admin_role");
+      if (!roleTableExists.data) {
+        Logger.warn("\u26A0\uFE0F \u89D2\u8272\u8868\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58");
+        return;
+      }
+      const roles = await this.db.getAll({
+        table: "addon_admin_role",
+        fields: ["code", "menus"]
+      });
+      const roleMenuPathsMap = new Map;
+      for (const role of roles.data.lists) {
+        if (!role?.code)
+          continue;
+        const menuPaths = this.assertMenuPathList(role.menus, role.code);
+        roleMenuPathsMap.set(role.code, menuPaths);
+      }
+      const roleCodes = Array.from(roleMenuPathsMap.keys());
+      if (roleCodes.length === 0) {
+        Logger.info("\u2705 \u6CA1\u6709\u9700\u8981\u7F13\u5B58\u7684\u89D2\u8272\u83DC\u5355\u6743\u9650");
+        return;
+      }
+      const roleKeys = roleCodes.map((code) => CacheKeys.roleMenus(code));
+      await this.redis.delBatch(roleKeys);
+      const items = [];
+      for (const roleCode of roleCodes) {
+        const menuPaths = roleMenuPathsMap.get(roleCode) || [];
+        const members = Array.from(new Set(menuPaths)).sort();
+        if (members.length > 0) {
+          items.push({ key: CacheKeys.roleMenus(roleCode), members });
+        }
+      }
+      if (items.length > 0) {
+        await this.redis.saddBatch(items);
+      }
+    } catch (error) {
+      Logger.error({ err: error, msg: "\u26A0\uFE0F \u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58\u5F02\u5E38\uFF08\u5C06\u963B\u65AD\u542F\u52A8\uFF09" });
+      throw new CoreError({
+        kind: "runtime",
+        message: "\u26A0\uFE0F \u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58\u5F02\u5E38\uFF08\u5C06\u963B\u65AD\u542F\u52A8\uFF09",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "cache",
+          operation: "rebuildRoleMenuPermissions"
+        }
+      });
+    }
+  }
   async refreshRoleApiPermissions(roleCode, apiPaths) {
     if (!roleCode || typeof roleCode !== "string") {
       throw new Error("roleCode \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
@@ -13826,10 +13900,30 @@ class CacheHelper {
       await this.redis.sadd(roleKey, members);
     }
   }
+  async refreshRoleMenuPermissions(roleCode, menuPaths) {
+    if (!roleCode || typeof roleCode !== "string") {
+      throw new Error("roleCode \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+    }
+    if (!Array.isArray(menuPaths)) {
+      throw new Error("menuPaths \u5FC5\u987B\u662F\u6570\u7EC4");
+    }
+    const normalizedPaths = menuPaths.map((p) => this.assertMenuPathname(p, `refreshRoleMenuPermissions: menuPaths \u5143\u7D20\uFF0CroleCode=${roleCode}`));
+    const roleKey = CacheKeys.roleMenus(roleCode);
+    if (normalizedPaths.length === 0) {
+      await this.redis.del(roleKey);
+      return;
+    }
+    const members = Array.from(new Set(normalizedPaths));
+    await this.redis.del(roleKey);
+    if (members.length > 0) {
+      await this.redis.sadd(roleKey, members);
+    }
+  }
   async cacheAll() {
     await this.cacheApis();
     await this.cacheMenus();
     await this.rebuildRoleApiPermissions();
+    await this.rebuildRoleMenuPermissions();
   }
   async getApis() {
     try {
@@ -13858,6 +13952,15 @@ class CacheHelper {
       return [];
     }
   }
+  async getRoleMenuPermissions(roleCode) {
+    try {
+      const permissions = await this.redis.smembers(CacheKeys.roleMenus(roleCode));
+      return permissions || [];
+    } catch (error) {
+      Logger.error({ err: error, roleCode, msg: "\u83B7\u53D6\u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58\u5931\u8D25" });
+      return [];
+    }
+  }
   async checkRolePermission(roleCode, apiPath) {
     try {
       const pathname = this.assertApiPathname(apiPath, "checkRolePermission: apiPath");
@@ -13867,6 +13970,15 @@ class CacheHelper {
       return false;
     }
   }
+  async checkRoleMenuPermission(roleCode, menuPath) {
+    try {
+      const pathname = this.assertMenuPathname(menuPath, "checkRoleMenuPermission: menuPath");
+      return await this.redis.sismember(CacheKeys.roleMenus(roleCode), pathname);
+    } catch (error) {
+      Logger.error({ err: error, roleCode, msg: "\u68C0\u67E5\u89D2\u8272\u83DC\u5355\u6743\u9650\u5931\u8D25" });
+      return false;
+    }
+  }
   async deleteRolePermissions(roleCode) {
     try {
       const result = await this.redis.del(CacheKeys.roleApis(roleCode));
@@ -13880,6 +13992,19 @@ class CacheHelper {
       return false;
     }
   }
+  async deleteRoleMenuPermissions(roleCode) {
+    try {
+      const result = await this.redis.del(CacheKeys.roleMenus(roleCode));
+      if (result > 0) {
+        Logger.info(`\u2705 \u5DF2\u5220\u9664\u89D2\u8272 ${roleCode} \u7684\u83DC\u5355\u6743\u9650\u7F13\u5B58`);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      Logger.error({ err: error, roleCode, msg: "\u5220\u9664\u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58\u5931\u8D25" });
+      return false;
+    }
+  }
 }
 
 // plugins/cache.ts
@@ -13921,57 +14046,6 @@ var configPlugin = {
 };
 var config_default = configPlugin;
 
-// utils/convertBigIntFields.ts
-function convertBigIntFields(arr, fields = ["id", "pid", "sort"]) {
-  if (arr === null || arr === undefined) {
-    return arr;
-  }
-  const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
-  const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
-  const convertRecord = (source) => {
-    const converted = {};
-    for (const [key, value] of Object.entries(source)) {
-      converted[key] = value;
-    }
-    for (const [key, value] of Object.entries(converted)) {
-      if (value === undefined || value === null) {
-        continue;
-      }
-      const shouldConvert = fields.includes(key) || key.endsWith("Id") || key.endsWith("_id") || key.endsWith("At") || key.endsWith("_at");
-      if (!shouldConvert) {
-        continue;
-      }
-      let bigintValue = null;
-      if (typeof value === "bigint") {
-        bigintValue = value;
-      } else if (typeof value === "string") {
-        if (!/^-?\d+$/.test(value)) {
-          continue;
-        }
-        try {
-          bigintValue = BigInt(value);
-        } catch {
-          continue;
-        }
-      } else {
-        continue;
-      }
-      if (bigintValue > MAX_SAFE_INTEGER_BIGINT || bigintValue < MIN_SAFE_INTEGER_BIGINT) {
-        throw new Error(`BIGINT \u5B57\u6BB5\u8D85\u51FA JS \u5B89\u5168\u6574\u6570\u8303\u56F4\uFF0C\u8BF7\u6539\u7528 bigint/string \u6216\u8C03\u6574\u5B57\u6BB5\u8BBE\u8BA1 (field: ${key}, value: ${String(value)})`);
-      }
-      converted[key] = Number(bigintValue);
-    }
-    return converted;
-  };
-  if (Array.isArray(arr)) {
-    return arr.map((item) => convertRecord(item));
-  }
-  if (typeof arr === "object") {
-    return convertRecord(arr);
-  }
-  return arr;
-}
-
 // lib/dbHelper.ts
 init_util();
 
@@ -15350,6 +15424,72 @@ class DbHelper {
   sql = null;
   isTransaction = false;
   idMode;
+  static convertBigIntFields(arr, fields) {
+    if (arr === null || arr === undefined) {
+      return arr;
+    }
+    const defaultFields = ["id", "pid", "sort"];
+    const buildFields = (userFields) => {
+      if (!userFields || userFields.length === 0) {
+        return defaultFields;
+      }
+      const merged = ["id", "pid", "sort"];
+      for (const f of userFields) {
+        if (typeof f !== "string") {
+          continue;
+        }
+        const trimmed = f.trim();
+        if (trimmed.length === 0) {
+          continue;
+        }
+        if (!merged.includes(trimmed)) {
+          merged.push(trimmed);
+        }
+      }
+      return merged;
+    };
+    const effectiveFields = buildFields(fields);
+    const fieldSet = new Set(effectiveFields);
+    const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+    const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+    const convertRecord = (source) => {
+      const converted = {};
+      for (const [key, value] of Object.entries(source)) {
+        let nextValue = value;
+        if (value !== undefined && value !== null) {
+          const shouldConvert = fieldSet.has(key) || key.endsWith("Id") || key.endsWith("_id") || key.endsWith("At") || key.endsWith("_at");
+          if (shouldConvert) {
+            let bigintValue = null;
+            if (typeof value === "bigint") {
+              bigintValue = value;
+            } else if (typeof value === "string") {
+              if (/^-?\d+$/.test(value)) {
+                try {
+                  bigintValue = BigInt(value);
+                } catch {
+                  bigintValue = null;
+                }
+              }
+            }
+            if (bigintValue !== null) {
+              if (bigintValue <= MAX_SAFE_INTEGER_BIGINT && bigintValue >= MIN_SAFE_INTEGER_BIGINT) {
+                nextValue = Number(bigintValue);
+              }
+            }
+          }
+        }
+        converted[key] = nextValue;
+      }
+      return converted;
+    };
+    if (Array.isArray(arr)) {
+      return arr.map((item) => convertRecord(item));
+    }
+    if (typeof arr === "object") {
+      return convertRecord(arr);
+    }
+    return arr;
+  }
   constructor(options) {
     this.redis = options.redis;
     if (typeof options.dbName !== "string" || options.dbName.trim() === "") {
@@ -15524,7 +15664,7 @@ class DbHelper {
         sql: execRes.sql
       };
     }
-    const convertedList = convertBigIntFields([deserialized]);
+    const convertedList = DbHelper.convertBigIntFields([deserialized], options.bigint);
     const data = convertedList[0] ?? deserialized;
     return {
       data,
@@ -15575,7 +15715,7 @@ class DbHelper {
     const deserializedList = camelList.map((item) => DbUtils.deserializeArrayFields(item)).filter((item) => item !== null);
     return {
       data: {
-        lists: convertBigIntFields(deserializedList),
+        lists: DbHelper.convertBigIntFields(deserializedList, options.bigint),
         total,
         page: prepared.page,
         limit: prepared.limit,
@@ -15597,6 +15737,8 @@ class DbHelper {
     };
     if (options.fields !== undefined)
       prepareOptions.fields = options.fields;
+    if (options.bigint !== undefined)
+      prepareOptions.bigint = options.bigint;
     if (options.where !== undefined)
       prepareOptions.where = options.where;
     if (options.joins !== undefined)
@@ -15637,7 +15779,7 @@ class DbHelper {
     }
     const camelResult = arrayKeysToCamel(result);
     const deserializedList = camelResult.map((item) => DbUtils.deserializeArrayFields(item)).filter((item) => item !== null);
-    const lists = convertBigIntFields(deserializedList);
+    const lists = DbHelper.convertBigIntFields(deserializedList, options.bigint);
     return {
       data: {
         lists,
@@ -16276,6 +16418,52 @@ class RedisHelper {
       return null;
     }
   }
+  async tryAcquireLock(key, token, ttlMs) {
+    try {
+      if (!key || typeof key !== "string") {
+        throw new Error("tryAcquireLock: key \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      if (!token || typeof token !== "string") {
+        throw new Error("tryAcquireLock: token \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      if (!(typeof ttlMs === "number" && Number.isFinite(ttlMs) && ttlMs > 0)) {
+        throw new Error("tryAcquireLock: ttlMs \u5FC5\u987B\u662F\u6B63\u6570");
+      }
+      const pkey = `${this.prefix}${key}`;
+      const startTime = Date.now();
+      const ttlMsString = String(Math.floor(ttlMs));
+      const res = await this.client.set(pkey, token, "NX", "PX", ttlMsString);
+      const duration = Date.now() - startTime;
+      this.logSlow("SET NX PX", pkey, duration, { ttlMs });
+      return res === "OK";
+    } catch (error) {
+      Logger.error({ err: error, msg: "Redis tryAcquireLock \u9519\u8BEF" });
+      return false;
+    }
+  }
+  async releaseLock(key, token) {
+    try {
+      if (!key || typeof key !== "string") {
+        throw new Error("releaseLock: key \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      if (!token || typeof token !== "string") {
+        throw new Error("releaseLock: token \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      const pkey = `${this.prefix}${key}`;
+      const startTime = Date.now();
+      const current = await this.client.get(pkey);
+      if (current !== token) {
+        return false;
+      }
+      const deleted = await this.client.del(pkey);
+      const duration = Date.now() - startTime;
+      this.logSlow("GET+DEL", pkey, duration);
+      return deleted > 0;
+    } catch (error) {
+      Logger.error({ err: error, msg: "Redis releaseLock \u9519\u8BEF" });
+      return false;
+    }
+  }
   async getString(key) {
     try {
       const pkey = `${this.prefix}${key}`;
@@ -16867,17 +17055,57 @@ class Befly {
       });
       this.plugins = await loadPlugins(plugins, this.context);
       this.assertStartContextReady();
-      await new SyncTable(this.context).run(tables);
-      await syncApi(this.context, apis);
-      await syncMenu(this.context, checkedMenus);
-      const devEmail = this.config.devEmail;
-      const devPassword = this.config.devPassword;
-      if (typeof devEmail === "string" && devEmail.length > 0 && typeof devPassword === "string" && devPassword.length > 0) {
-        await syncDev(this.context, { devEmail, devPassword });
+      const syncLockKey = "sync:lock";
+      const syncReadyKey = "sync:ready";
+      const syncLockTtlMs = 10 * 60 * 1000;
+      const syncWaitReadyMaxMs = 120 * 1000;
+      const syncWaitPollMs = 250;
+      const syncToken = `${process.pid}:${Bun.nanoseconds()}`;
+      const ctx = this.context;
+      const acquired = await ctx.redis.tryAcquireLock(syncLockKey, syncToken, syncLockTtlMs);
+      if (acquired) {
+        Logger.info({ key: syncLockKey, msg: "\u2705 \u5DF2\u83B7\u53D6\u542F\u52A8\u540C\u6B65\u9501\uFF0C\u5C06\u6267\u884C\u81EA\u52A8\u540C\u6B65" });
+        await ctx.redis.del(syncReadyKey);
+        try {
+          await new SyncTable(ctx).run(tables);
+          await syncApi(ctx, apis);
+          await syncMenu(ctx, checkedMenus);
+          const devEmail = this.config.devEmail;
+          const devPassword = this.config.devPassword;
+          if (typeof devEmail === "string" && devEmail.length > 0 && typeof devPassword === "string" && devPassword.length > 0) {
+            await syncDev(ctx, { devEmail, devPassword });
+          } else {
+            Logger.debug("\u8DF3\u8FC7 syncDev\uFF1A\u672A\u914D\u7F6E devEmail/devPassword");
+          }
+          await syncCache(ctx);
+          await ctx.redis.setString(syncReadyKey, String(Date.now()), 60 * 60);
+        } finally {
+          const released = await ctx.redis.releaseLock(syncLockKey, syncToken);
+          if (!released) {
+            Logger.warn({ key: syncLockKey, msg: "\u540C\u6B65\u9501\u672A\u80FD\u4E3B\u52A8\u91CA\u653E\uFF08\u5C06\u4F9D\u8D56 TTL \u81EA\u52A8\u91CA\u653E\uFF09" });
+          }
+        }
       } else {
-        Logger.debug("\u8DF3\u8FC7 syncDev\uFF1A\u672A\u914D\u7F6E devEmail/devPassword");
+        Logger.info({ key: syncLockKey, msg: "\u542F\u52A8\u540C\u6B65\u9501\u88AB\u5360\u7528\uFF1A\u7B49\u5F85\u540C\u6B65\u5B8C\u6210\u6807\u8BB0" });
+        const waitStart = Date.now();
+        while (true) {
+          const ready = await ctx.redis.getString(syncReadyKey);
+          if (typeof ready === "string" && ready.length > 0) {
+            Logger.info({ key: syncReadyKey, msg: "\u2705 \u68C0\u6D4B\u5230\u540C\u6B65\u5B8C\u6210\u6807\u8BB0\uFF0C\u5C06\u8DF3\u8FC7\u81EA\u52A8\u540C\u6B65" });
+            break;
+          }
+          const elapsed = Date.now() - waitStart;
+          if (elapsed >= syncWaitReadyMaxMs) {
+            throw new CoreError({
+              kind: "runtime",
+              message: `\u542F\u52A8\u7B49\u5F85\u540C\u6B65\u5B8C\u6210\u8D85\u65F6\uFF08${syncWaitReadyMaxMs}ms\uFF09\uFF1A\u8BF7\u68C0\u67E5\u662F\u5426\u6709\u5B9E\u4F8B\u5361\u5728\u540C\u6B65\u9636\u6BB5\u6216 Redis \u9501 TTL \u8FC7\u957F`,
+              logged: true,
+              meta: { subsystem: "start", operation: "waitSyncReady" }
+            });
+          }
+          await Bun.sleep(syncWaitPollMs);
+        }
       }
-      await syncCache(this.context);
       this.hooks = await loadHooks(hooks);
       this.apis = await loadApis(apis);
       const apiFetch = apiHandler(this.apis, this.hooks, this.context);
@@ -16913,10 +17141,7 @@ class Befly {
         }
       });
       const finalStartupTime = calcPerfTime(serverStartTime);
-      const processRole = getProcessRole(env);
-      const roleLabel = processRole.role === "primary" ? "\u4E3B\u8FDB\u7A0B" : `\u5DE5\u4F5C\u8FDB\u7A0B #${processRole.instanceId}`;
-      const envLabel = processRole.env === "standalone" ? "" : ` [${processRole.env}]`;
-      Logger.info(`${this.config.appName} \u542F\u52A8\u6210\u529F! (${roleLabel}${envLabel})`);
+      Logger.info(`${this.config.appName} \u542F\u52A8\u6210\u529F!`);
       Logger.info(`\u670D\u52A1\u5668\u542F\u52A8\u8017\u65F6: ${finalStartupTime}`);
       Logger.info(`\u670D\u52A1\u5668\u76D1\u542C\u5730\u5740: ${server.url}`);
       return server;