@sjtdev/koishi-plugin-dota2tracker 2.5.3 → 2.5.4

package/changelog.md

@@ -1,5 +1,15 @@
 # 更新日志
 
+### [2.5.4](https://github.com/sjtdev/koishi-plugin-dota2tracker/compare/v2.5.3...v2.5.4) (2026-02-26)
+
+### 🚀 功能优化
+
+* **database:** 增加缓存群友列表机制，加入对拉取有效群友时的检测，每小时更新缓存 ([1ac1df9](https://github.com/sjtdev/koishi-plugin-dota2tracker/commit/1ac1df9513a883b17031fdc3e912fccc0af8a3e2)), closes [#17](https://github.com/sjtdev/koishi-plugin-dota2tracker/issues/17)
+
+### 🐛 Bug 修复
+
+* **match-watcher:** 修复无有效群友时还会发送查询请求 ([a8d1e8c](https://github.com/sjtdev/koishi-plugin-dota2tracker/commit/a8d1e8c173d71b850516912729e398943d3ea391))
+
 ### [2.5.3](https://github.com/sjtdev/koishi-plugin-dota2tracker/compare/v2.5.2...v2.5.3) (2026-02-23)
 
 ### 🎨 样式

package/lib/index.js

@@ -2313,13 +2313,13 @@ var DatabaseService = class extends import_koishi7.Service {
   }
   constructor(ctx) {
     super(ctx, "dota2tracker.database", true);
-    ctx.model.extend("dt_subscribed_guilds", { id: "unsigned", guildId: "string", platform: "string" }, { autoInc: true });
+    ctx.model.extend("dt_subscribed_guilds", { id: "unsigned", channelId: { type: "string", legacy: ["guildId"] }, platform: "string" }, { autoInc: true });
     ctx.model.extend(
       "dt_subscribed_players",
       {
         id: "unsigned",
         userId: "string",
-        guildId: "string",
+        channelId: { type: "string", legacy: ["guildId"] },
         platform: "string",
         steamId: "integer",
         nickName: "string",
@@ -2328,6 +2328,62 @@ var DatabaseService = class extends import_koishi7.Service {
       { autoInc: true }
     );
     ctx.model.extend("dt_match_extension", { matchId: "string", startTime: "timestamp", data: "json" }, { autoInc: false, primary: ["matchId"] });
+    ctx.cron("0 * * * *", async () => {
+      await this.refreshAllGuildMemberCaches();
+    });
+  }
+  /** 群成员列表内存缓存： Map<"platform:channelId", Set<userId>> */
+  guildMemberCache = /* @__PURE__ */ new Map();
+  /**
+   * 刷新指定频道的群成员缓存。
+   * 通过 channel 表获取 assignee（bot selfId），再调用 bot.getGuildMemberList。
+   * 失败时记录 warn 并清除该 key（保守策略）。
+   */
+  async refreshGuildMemberCache(platform, channelId) {
+    const cacheKey = `${platform}:${channelId}`;
+    try {
+      const channelRow = (await this.ctx.database.get("channel", { id: channelId })).at(0);
+      const selfId = channelRow?.assignee;
+      const guildId = channelRow?.guildId ?? channelId;
+      if (!selfId) {
+        this.guildMemberCache.delete(cacheKey);
+        return;
+      }
+      const bot = this.ctx.bots[`${platform}:${selfId}`];
+      if (!bot) {
+        this.guildMemberCache.delete(cacheKey);
+        return;
+      }
+      const members = await bot.getGuildMemberList(guildId);
+      const userIds = new Set(members.data.map((m) => m.user.id));
+      this.guildMemberCache.set(cacheKey, userIds);
+    } catch (error) {
+      this.logger.warn(`获取频道 ${cacheKey} 成员列表失败，已清除对应缓存：` + error);
+      this.guildMemberCache.delete(cacheKey);
+    }
+  }
+  /** 全量刷新所有已订阅频道的群成员缓存（每小时 cron 调用） */
+  async refreshAllGuildMemberCaches() {
+    const subscribedChannels = await this.ctx.database.get("dt_subscribed_guilds", void 0);
+    await Promise.allSettled(subscribedChannels.map((ch) => this.refreshGuildMemberCache(ch.platform, ch.channelId)));
+  }
+  /**
+   * 判断玩家是否仍在群组中。
+   * 缓存未命中（冷启动阶段）时保守放行，返回 true。
+   */
+  isPlayerInGuild(platform, channelId, userId) {
+    const cached = this.guildMemberCache.get(`${platform}:${channelId}`);
+    if (!cached) return true;
+    return cached.has(userId);
+  }
+  /** 删除指定频道的群成员缓存（取消订阅时内部调用） */
+  deleteGuildMemberCache(platform, channelId) {
+    this.guildMemberCache.delete(`${platform}:${channelId}`);
+  }
+  /** 从缓存中移除单个用户（取消绑定时内部调用，保留频道内其他成员的缓存）*/
+  removeUserFromGuildMemberCache(platform, channelId, userId) {
+    const cached = this.guildMemberCache.get(`${platform}:${channelId}`);
+    if (cached) cached.delete(userId);
   }
   async insertMatchExtension(matchId, startTime, data) {
     return this.ctx.database.upsert("dt_match_extension", [{ matchId: String(matchId), startTime, data }]);
@@ -2345,9 +2401,8 @@ var DatabaseService = class extends import_koishi7.Service {
     return this.ctx.database.set("dt_subscribed_players", playerId, { rank });
   }
   async getActiveSubscribedPlayers() {
-    const subscribedGuilds = await this.ctx.database.get("dt_subscribed_guilds", void 0);
-    const subscribedPlayersInGuild = (await this.ctx.database.get("dt_subscribed_players", void 0)).filter((player) => subscribedGuilds.some((guild) => guild.guildId == player.guildId));
-    return subscribedPlayersInGuild;
+    const subscribedChannels = await this.ctx.database.get("dt_subscribed_guilds", void 0);
+    return (await this.ctx.database.get("dt_subscribed_players", void 0)).filter((player) => subscribedChannels.some((ch) => ch.channelId == player.channelId)).filter((player) => this.isPlayerInGuild(player.platform, player.channelId, player.userId));
   }
   async isUserBinded(session) {
     const subscribedPlayer = await this.ctx.database.get("dt_subscribed_players", this.getUserQuery(session));
@@ -2358,23 +2413,32 @@ var DatabaseService = class extends import_koishi7.Service {
     return subscribedPlayer.length > 0 ? subscribedPlayer[0] : null;
   }
   async bindUser(session, steamId, nickName) {
-    return this.ctx.database.create("dt_subscribed_players", {
+    const result = await this.ctx.database.create("dt_subscribed_players", {
       ...this.getUserQuery(session),
       steamId: Number(steamId),
       nickName: nickName || ""
     });
+    this.refreshGuildMemberCache(session.event.platform, session.event.channel.id);
+    return result;
   }
   async unbindUser(session) {
+    this.removeUserFromGuildMemberCache(session.event.platform, session.event.channel.id, session.event.user.id);
     return this.ctx.database.remove("dt_subscribed_players", this.getUserQuery(session));
   }
+  async renamePlayer(playerId, nickName) {
+    return this.ctx.database.set("dt_subscribed_players", playerId, { nickName });
+  }
   async isChannelSubscribed(session) {
     const subscribedChannels = await this.ctx.database.get("dt_subscribed_guilds", this.getChannelQuery(session));
     return subscribedChannels.length > 0;
   }
   async subscribeChannel(session) {
-    return this.ctx.database.create("dt_subscribed_guilds", this.getChannelQuery(session));
+    const result = await this.ctx.database.create("dt_subscribed_guilds", this.getChannelQuery(session));
+    this.refreshGuildMemberCache(session.event.platform, session.event.channel.id);
+    return result;
   }
   async unSubscribeChannel(session) {
+    this.deleteGuildMemberCache(session.event.platform, session.event.channel.id);
     return this.ctx.database.remove("dt_subscribed_guilds", this.getChannelQuery(session));
   }
   async getSubscribedMembersInChannel(session) {
@@ -2385,13 +2449,13 @@ var DatabaseService = class extends import_koishi7.Service {
    */
   getChannelQuery(session) {
     return {
-      guildId: session.event.channel.id,
+      channelId: session.event.channel.id,
       platform: session.event.platform
     };
   }
   getUserQuery(session) {
     return {
-      guildId: session.event.channel.id,
+      channelId: session.event.channel.id,
       platform: session.event.platform,
       userId: session.event.user.id
     };
@@ -2399,14 +2463,14 @@ var DatabaseService = class extends import_koishi7.Service {
   /** 从已订阅玩家中查找玩家返回SteamId，不需要以昵称匹配时仅需传入Session */
   async getSubscribedPlayerByNickNameOrSession(session, nickName) {
     const player = (await this.ctx.database.get("dt_subscribed_players", {
-      guildId: session.event.channel.id,
+      channelId: session.event.channel.id,
       platform: session.event.platform,
       ...nickName ? { nickName } : { userId: session.event.user.id }
     }))?.[0];
     return player;
   }
-  getChannelInfo({ platform, guildId }) {
-    return `${platform}:${guildId}`;
+  getChannelInfo({ platform, channelId }) {
+    return `${platform}:${channelId}`;
   }
 };
 
@@ -3301,6 +3365,7 @@ var MatchWatcherTask = class extends import_koishi13.Service {
   async discovery() {
     try {
       const activePlayers = await this.ctx.dota2tracker.database.getActiveSubscribedPlayers();
+      if (activePlayers.length === 0) return;
       const uniqueSteamIds = activePlayers.map((player) => player.steamId).filter((steamId, index, self) => self.indexOf(steamId) === index);
       const playersData = (await this.ctx.dota2tracker.stratzAPI.queryPlayersLastMatchRankInfo({ steamAccountIds: uniqueSteamIds })).players;
       await this.discoverNewMatches(playersData, activePlayers);
@@ -3320,10 +3385,10 @@ var MatchWatcherTask = class extends import_koishi13.Service {
       }
       const playersByGuild = /* @__PURE__ */ new Map();
       for (const player of relevantActivePlayers) {
-        const guildKey = `${player.platform}:${player.guildId}`;
+        const guildKey = `${player.platform}:${player.channelId}`;
         if (!playersByGuild.has(guildKey)) {
           playersByGuild.set(guildKey, {
-            guildInfo: { platform: player.platform, channelId: player.guildId, guildId: player.guildId },
+            guildInfo: { platform: player.platform, channelId: player.channelId },
             players: []
           });
         }
@@ -3344,7 +3409,7 @@ var MatchWatcherTask = class extends import_koishi13.Service {
         });
         messageToLogger.push({
           platform: guildInfo.platform,
-          guildId: guildInfo.guildId,
+          guildId: guildInfo.channelId,
           players
         });
         subscribers.push(subscriber);
@@ -3381,12 +3446,12 @@ var MatchWatcherTask = class extends import_koishi13.Service {
           if (prevRank.medal !== currRank.medal || prevRank.star !== currRank.star && this.config.rankBroadStar || prevRank.leader !== currRank.leader && this.config.rankBroadLeader) {
             let guildMember;
             try {
-              guildMember = await this.ctx.bots.find((bot) => bot.platform == subPlayer.platform)?.getGuildMember?.(subPlayer.guildId, subPlayer.userId);
+              guildMember = await this.ctx.bots.find((bot) => bot.platform == subPlayer.platform)?.getGuildMember?.(subPlayer.channelId, subPlayer.userId);
             } catch (error) {
               this.logger.warn(this.ctx.dota2tracker.i18n.gt("dota2tracker.logger.fetch_guilds_failed") + error);
             }
             const name2 = subPlayer.nickName ?? guildMember?.nick ?? playersData.find((player) => player.steamAccount.id == subPlayer.steamId)?.steamAccount.name ?? String(subPlayer.steamId);
-            const languageTag = await this.ctx.dota2tracker.i18n.getLanguageTag({ channelId: subPlayer.guildId });
+            const languageTag = await this.ctx.dota2tracker.i18n.getLanguageTag({ channelId: subPlayer.channelId });
             if (this.config.rankBroadFun === true) {
               const img = await this.ctx.dota2tracker.view.renderToImageByFile(
                 {
@@ -3401,13 +3466,13 @@ var MatchWatcherTask = class extends import_koishi13.Service {
                 "rank" /* Rank */,
                 languageTag
               );
-              await this.ctx.broadcast([`${subPlayer.platform}:${subPlayer.guildId}`], img);
+              await this.ctx.broadcast([`${subPlayer.platform}:${subPlayer.channelId}`], img);
             } else {
               const message = this.ctx.dota2tracker.messageBuilder.buildRankChangedMessage(languageTag, name2, prevRank, currRank);
-              await this.ctx.broadcast([`${subPlayer.platform}:${subPlayer.guildId}`], message);
+              await this.ctx.broadcast([`${subPlayer.platform}:${subPlayer.channelId}`], message);
             }
             this.ctx.dota2tracker.database.setPlayerRank(subPlayer.id, rankMap.get(subPlayer.steamId));
-            this.logger.info(this.ctx.dota2tracker.i18n.gt("dota2tracker.logger.rank_sent", { platform: subPlayer.platform, guildId: subPlayer.guildId, player: { nickName: subPlayer.nickName, steamId: subPlayer.steamId } }));
+            this.logger.info(this.ctx.dota2tracker.i18n.gt("dota2tracker.logger.rank_sent", { platform: subPlayer.platform, guildId: subPlayer.channelId, player: { nickName: subPlayer.nickName, steamId: subPlayer.steamId } }));
           }
         } else {
           this.ctx.dota2tracker.database.setPlayerRank(subPlayer.id, rankMap.get(subPlayer.steamId));
@@ -3451,8 +3516,7 @@ var ParsePollingTask = class extends import_koishi14.Service {
       source: "AUTOMATIC",
       type: "CHANNEL",
       platform: target.platform,
-      channelId: target.channelId,
-      guildId: target.guildId
+      channelId: target.channelId
     };
   }
   add(matchId, subscribers) {
@@ -3591,12 +3655,12 @@ var DailyReportTask = class extends import_koishi15.Service {
     }
   }
   async report_legacy(timeAgo, titleKey, showCombi) {
-    const subscribedGuilds = await this.ctx.database.get("dt_subscribed_guilds", void 0);
-    const subscribedPlayersInGuild = (await this.ctx.database.get("dt_subscribed_players", void 0)).filter((player) => subscribedGuilds.some((guild) => guild.guildId == player.guildId));
-    const steamIds = subscribedPlayersInGuild.map((player) => player.steamId).filter((value, index, self) => self.indexOf(value) === index);
+    const subscribedChannels = await this.ctx.database.get("dt_subscribed_guilds", void 0);
+    const subscribedPlayersInChannel = (await this.ctx.database.get("dt_subscribed_players", void 0)).filter((player) => subscribedChannels.some((ch) => ch.channelId == player.channelId));
+    const steamIds = subscribedPlayersInChannel.map((player) => player.steamId).filter((value, index, self) => self.indexOf(value) === index);
     const players = (await this.ctx.dota2tracker.stratzAPI.queryPlayersMatchesForDaily_legacy(steamIds, timeAgo)).players.filter((player) => player.matches?.length > 0);
     const matches = players.map((player) => player.matches.map((match) => match)).flat().filter((item, index, self) => index === self.findIndex((t) => t.id === item.id));
-    for (let subPlayer of subscribedPlayersInGuild) {
+    for (let subPlayer of subscribedPlayersInChannel) {
       let player = players.find((player2) => subPlayer.steamId == player2.steamAccount.id);
       if (!player) continue;
       let guildMember;
@@ -3615,8 +3679,8 @@ var DailyReportTask = class extends import_koishi15.Service {
       player.avgImp = roundToDecimalPlaces(player.matches.reduce((acc, match) => acc + match.players.find((innerPlayer) => innerPlayer.steamAccount.id == player.steamAccount.id).imp, 0) / player.matches.length, 0);
       subPlayer = Object.assign(subPlayer, player);
     }
-    for (let guild of subscribedGuilds) {
-      const currentsubscribedPlayers = subscribedPlayersInGuild.filter((player) => player.platform == guild.platform && player.guildId == guild.guildId && player.matches?.length);
+    for (let channel of subscribedChannels) {
+      const currentsubscribedPlayers = subscribedPlayersInChannel.filter((player) => player.platform == channel.platform && player.channelId == channel.channelId && player.matches?.length);
       if (currentsubscribedPlayers.length) {
         const currentsubscribedPlayersIds = currentsubscribedPlayers.map((player) => player.steamId);
         const combinationsMap = /* @__PURE__ */ new Map();
@@ -3642,9 +3706,9 @@ var DailyReportTask = class extends import_koishi15.Service {
         });
         const combinations = Array.from(combinationsMap.values());
         try {
-          const languageTag = await this.ctx.dota2tracker.i18n.getLanguageTag({ channelId: guild.guildId });
+          const languageTag = await this.ctx.dota2tracker.i18n.getLanguageTag({ channelId: channel.channelId });
           await this.ctx.broadcast(
-            [`${guild.platform}:${guild.guildId}`],
+            [`${channel.platform}:${channel.channelId}`],
             await this.ctx.dota2tracker.view.renderToImageByFile(
               {
                 title: this.ctx.dota2tracker.i18n.$t(languageTag, titleKey),
@@ -3661,7 +3725,7 @@ var DailyReportTask = class extends import_koishi15.Service {
               languageTag
             )
           );
-          this.logger.info(this.ctx.dota2tracker.i18n.gt("dota2tracker.logger.report_sent", { title: this.ctx.dota2tracker.i18n.$t(languageTag, titleKey), guildId: guild.guildId, platform: guild.platform }));
+          this.logger.info(this.ctx.dota2tracker.i18n.gt("dota2tracker.logger.report_sent", { title: this.ctx.dota2tracker.i18n.$t(languageTag, titleKey), guildId: channel.channelId, platform: channel.platform }));
         } catch (error) {
           this.logger.error(error);
         }
@@ -4025,7 +4089,7 @@ function registerUserCommand(ctx) {
     if (!session.isDirect) {
       const sessionPlayer = await ctx.dota2tracker.database.getBindedUser(session);
       if (sessionPlayer) {
-        await ctx.database.remove("dt_subscribed_players", sessionPlayer.id);
+        ctx.dota2tracker.database.unbindUser(session);
         return session.text(".unbind_success");
       } else {
         return session.text(".not_binded");
@@ -4045,7 +4109,7 @@ function registerUserCommand(ctx) {
         if (nick_name === sessionPlayer.nickName) {
           return session.text(".nick_name_same");
         }
-        await ctx.database.set("dt_subscribed_players", sessionPlayer.id, { nickName: nick_name });
+        await ctx.dota2tracker.database.renamePlayer(sessionPlayer.id, nick_name);
         return session.text(".rename_success", { nick_name });
       } else {
         return session.text(".not_binded");
@@ -4683,7 +4747,7 @@ var DailyReportService = class _DailyReportService extends import_koishi18.Servi
   static groupUsersByChannel(users) {
     const groups = /* @__PURE__ */ new Map();
     for (const user of users) {
-      const key = `${user.platform}:${user.guildId}`;
+      const key = `${user.platform}:${user.channelId}`;
       if (!groups.has(key)) groups.set(key, []);
       groups.get(key).push(user);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sjtdev/koishi-plugin-dota2tracker",
   "description": "koishi插件-追踪群友的DOTA2对局 | A Koishi plugin to track Dota 2 matches",
-  "version": "2.5.3",
+  "version": "2.5.4",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [