koishi-plugin-chat-analyse 0.3.1 → 0.3.3

package/lib/Collector.d.ts

@@ -41,12 +41,11 @@ export declare class Collector {
     private static readonly FLUSH_INTERVAL;
     /** @const {number} BUFFER_THRESHOLD - 内存缓存区触发自动刷新的消息数量阈值。 */
     private static readonly BUFFER_THRESHOLD;
-    /** @member {Omit<Tables['analyse_cache'], 'id'>[]} cacheBuffer - 用于暂存原始消息的内存缓冲区，以减少数据库写入频率。 */
-    private cacheBuffer;
-    /** @member {Map<string, number>} uidCache - 用户 uid 的内存缓存，避免重复查询数据库。*/
-    private uidCache;
-    /** @member {Map<string, Promise<number>>} pendingUidRequests - 用于处理并发获取 uid 的请求锁。*/
-    private pendingUidRequests;
+    private msgStatBuffer;
+    private cmdStatBuffer;
+    private oriCacheBuffer;
+    private userCache;
+    private pendingUserRequests;
     private flushInterval;
     /**
      * @constructor
@@ -71,13 +70,13 @@ export declare class Collector {
     /**
      * @private
      * @async
-     * @method getOrCreateUser
-     * @description 高效地获取或创建用户的中央记录 (`analyse_user`)。
+     * @method getOrCreateCachedUser
+     * @description 高效地获取或创建用户的中央记录，并全面利用缓存。
      * @param {Session} session - Koishi 会话对象，用于获取用户信息和 Bot 实例。
      * @param {string} channelId - 消息所在的频道或群组 ID。
-     * @returns {Promise<number | null>} 返回用户的唯一 `uid`，如果操作失败则返回 `null`。
+     * @returns {Promise<UserCache | null>} 返回用户的缓存对象，如果操作失败则返回 `null`。
      */
-    private getOrCreateUser;
+    private getOrCreateCachedUser;
     /**
      * @private
      * @method sanitizeContent
@@ -89,8 +88,8 @@ export declare class Collector {
     /**
      * @private
      * @async
-     * @method flushCacheBuffer
-     * @description 将内存中的消息缓存 (`cacheBuffer`) 批量写入数据库。
+     * @method flushBuffers
+     * @description 将所有内存中的缓冲区数据批量写入数据库。
      */
-    private flushCacheBuffer;
+    private flushBuffers;
 }

package/lib/index.js

@@ -42,13 +42,11 @@ var Collector = class _Collector {
     this.config = config;
     this.defineModels();
     ctx.on("message", (session) => this.handleMessage(session));
-    if (this.config.enableOriRecord) {
-      this.flushInterval = setInterval(() => this.flushCacheBuffer(), _Collector.FLUSH_INTERVAL);
-      ctx.on("dispose", () => {
-        clearInterval(this.flushInterval);
-        this.flushCacheBuffer();
-      });
-    }
+    this.flushInterval = setInterval(() => this.flushBuffers(), _Collector.FLUSH_INTERVAL);
+    ctx.on("dispose", () => {
+      clearInterval(this.flushInterval);
+      this.flushBuffers();
+    });
   }
   static {
     __name(this, "Collector");
@@ -57,12 +55,13 @@ var Collector = class _Collector {
   static FLUSH_INTERVAL = 60 * 1e3;
   /** @const {number} BUFFER_THRESHOLD - 内存缓存区触发自动刷新的消息数量阈值。 */
   static BUFFER_THRESHOLD = 100;
-  /** @member {Omit<Tables['analyse_cache'], 'id'>[]} cacheBuffer - 用于暂存原始消息的内存缓冲区，以减少数据库写入频率。 */
-  cacheBuffer = [];
-  /** @member {Map<string, number>} uidCache - 用户 uid 的内存缓存，避免重复查询数据库。*/
-  uidCache = /* @__PURE__ */ new Map();
-  /** @member {Map<string, Promise<number>>} pendingUidRequests - 用于处理并发获取 uid 的请求锁。*/
-  pendingUidRequests = /* @__PURE__ */ new Map();
+  // 统一的缓冲区
+  msgStatBuffer = /* @__PURE__ */ new Map();
+  cmdStatBuffer = /* @__PURE__ */ new Map();
+  oriCacheBuffer = [];
+  // 用户缓存
+  userCache = /* @__PURE__ */ new Map();
+  pendingUserRequests = /* @__PURE__ */ new Map();
   flushInterval;
   /**
    * @private
@@ -111,35 +110,39 @@ var Collector = class _Collector {
       const { userId, channelId, guildId, content, timestamp, argv, elements } = session;
       const effectiveId = channelId || guildId;
       if (!effectiveId || !userId || !timestamp || !content?.trim()) return;
-      const uid = await this.getOrCreateUser(session, effectiveId);
-      if (!uid) return;
+      const user = await this.getOrCreateCachedUser(session, effectiveId);
+      if (!user) return;
+      const { uid } = user;
+      const messageTime = new Date(timestamp);
       if (argv?.command) {
-        await this.ctx.database.upsert("analyse_cmd", (row) => [{
-          uid,
-          command: argv.command.name,
-          count: import_koishi.$.add(import_koishi.$.ifNull(row.count, import_koishi.$.literal(0)), 1),
-          timestamp: /* @__PURE__ */ new Date()
-        }]);
+        const key = `${uid}:${argv.command.name}`;
+        const existing = this.cmdStatBuffer.get(key);
+        if (existing) {
+          existing.count++;
+          existing.timestamp = messageTime;
+        } else {
+          this.cmdStatBuffer.set(key, { uid, command: argv.command.name, count: 1, timestamp: messageTime });
+        }
       }
-      const messageTime = new Date(timestamp);
       const hourStart = new Date(messageTime.getFullYear(), messageTime.getMonth(), messageTime.getDate(), messageTime.getHours());
       const uniqueElementTypes = new Set(elements.map((e) => e.type));
       for (const type of uniqueElementTypes) {
-        await this.ctx.database.upsert("analyse_msg", (row) => [{
-          uid,
-          type,
-          hour: hourStart,
-          count: import_koishi.$.add(import_koishi.$.ifNull(row.count, 0), 1),
-          timestamp: messageTime
-        }]);
+        const key = `${uid}:${type}:${hourStart.toISOString()}`;
+        const existing = this.msgStatBuffer.get(key);
+        if (existing) {
+          existing.count++;
+          existing.timestamp = messageTime;
+        } else {
+          this.msgStatBuffer.set(key, { uid, type, hour: hourStart, count: 1, timestamp: messageTime });
+        }
       }
       if (this.config.enableOriRecord) {
-        this.cacheBuffer.push({
+        this.oriCacheBuffer.push({
           uid,
           content: this.sanitizeContent(elements),
-          timestamp: new Date(timestamp)
+          timestamp: messageTime
         });
-        if (this.cacheBuffer.length >= _Collector.BUFFER_THRESHOLD) await this.flushCacheBuffer();
+        if (this.oriCacheBuffer.length >= _Collector.BUFFER_THRESHOLD) await this.flushBuffers();
       }
     } catch (error) {
       this.ctx.logger.warn("消息处理出错:", error);
@@ -148,45 +151,50 @@ var Collector = class _Collector {
   /**
    * @private
    * @async
-   * @method getOrCreateUser
-   * @description 高效地获取或创建用户的中央记录 (`analyse_user`)。
+   * @method getOrCreateCachedUser
+   * @description 高效地获取或创建用户的中央记录，并全面利用缓存。
    * @param {Session} session - Koishi 会话对象，用于获取用户信息和 Bot 实例。
    * @param {string} channelId - 消息所在的频道或群组 ID。
-   * @returns {Promise<number | null>} 返回用户的唯一 `uid`，如果操作失败则返回 `null`。
+   * @returns {Promise<UserCache | null>} 返回用户的缓存对象，如果操作失败则返回 `null`。
    */
-  async getOrCreateUser(session, channelId) {
+  async getOrCreateCachedUser(session, channelId) {
     const { userId, bot, guildId } = session;
     const cacheKey = `${channelId}:${userId}`;
-    if (this.uidCache.has(cacheKey)) return this.uidCache.get(cacheKey);
-    if (this.pendingUidRequests.has(cacheKey)) return this.pendingUidRequests.get(cacheKey);
+    if (this.userCache.has(cacheKey)) return this.userCache.get(cacheKey);
+    if (this.pendingUserRequests.has(cacheKey)) return this.pendingUserRequests.get(cacheKey);
     const promise = (async () => {
       try {
-        const existing = await this.ctx.database.get("analyse_user", { channelId, userId }, ["uid"]);
+        const existing = await this.ctx.database.get("analyse_user", { channelId, userId });
         if (existing.length > 0) {
-          this.uidCache.set(cacheKey, existing[0].uid);
-          return existing[0].uid;
+          const { uid: uid2, userName: userName2, channelName: channelName2 } = existing[0];
+          const cachedUser2 = { uid: uid2, userName: userName2, channelName: channelName2 };
+          this.userCache.set(cacheKey, cachedUser2);
+          return cachedUser2;
         }
         const [guild, member] = await Promise.all([
           guildId ? bot.getGuild(guildId).catch(() => null) : Promise.resolve(null),
           guildId ? bot.getGuildMember(guildId, userId).catch(() => null) : Promise.resolve(null)
         ]);
         const user = !member ? await bot.getUser(userId).catch(() => null) : null;
-        const newUser = await this.ctx.database.create("analyse_user", {
+        const newUserRecord = {
           channelId,
           userId,
           channelName: guild?.name || channelId,
           userName: member?.nick || member?.name || user?.name || userId
-        });
-        this.uidCache.set(cacheKey, newUser.uid);
-        return newUser.uid;
+        };
+        const createdUser = await this.ctx.database.create("analyse_user", newUserRecord);
+        const { uid, userName, channelName } = createdUser;
+        const cachedUser = { uid, userName, channelName };
+        this.userCache.set(cacheKey, cachedUser);
+        return cachedUser;
       } catch (error) {
-        this.ctx.logger.error(`创建或获取用户(${cacheKey}) UID 失败:`, error);
+        this.ctx.logger.error(`创建或获取用户(${cacheKey})失败:`, error);
         return null;
       } finally {
-        this.pendingUidRequests.delete(cacheKey);
+        this.pendingUserRequests.delete(cacheKey);
       }
     })();
-    this.pendingUidRequests.set(cacheKey, promise);
+    this.pendingUserRequests.set(cacheKey, promise);
     return promise;
   }
   /**
@@ -211,17 +219,43 @@ var Collector = class _Collector {
   /**
    * @private
    * @async
-   * @method flushCacheBuffer
-   * @description 将内存中的消息缓存 (`cacheBuffer`) 批量写入数据库。
+   * @method flushBuffers
+   * @description 将所有内存中的缓冲区数据批量写入数据库。
    */
-  async flushCacheBuffer() {
-    if (this.cacheBuffer.length === 0) return;
-    const bufferToFlush = this.cacheBuffer;
-    this.cacheBuffer = [];
+  async flushBuffers() {
+    const cmdBufferToFlush = Array.from(this.cmdStatBuffer.values());
+    const msgBufferToFlush = Array.from(this.msgStatBuffer.values());
+    const advancedBufferToFlush = this.oriCacheBuffer;
+    this.cmdStatBuffer.clear();
+    this.msgStatBuffer.clear();
+    this.oriCacheBuffer = [];
     try {
-      await this.ctx.database.upsert("analyse_cache", bufferToFlush);
+      if (cmdBufferToFlush.length > 0) {
+        await this.ctx.database.upsert(
+          "analyse_cmd",
+          (row) => cmdBufferToFlush.map((item) => ({
+            uid: item.uid,
+            command: item.command,
+            count: import_koishi.$.add(import_koishi.$.ifNull(row.count, 0), item.count),
+            timestamp: item.timestamp
+          }))
+        );
+      }
+      if (msgBufferToFlush.length > 0) {
+        await this.ctx.database.upsert(
+          "analyse_msg",
+          (row) => msgBufferToFlush.map((item) => ({
+            uid: item.uid,
+            type: item.type,
+            hour: item.hour,
+            count: import_koishi.$.add(import_koishi.$.ifNull(row.count, 0), item.count),
+            timestamp: item.timestamp
+          }))
+        );
+      }
+      if (advancedBufferToFlush.length > 0) await this.ctx.database.upsert("analyse_cache", advancedBufferToFlush);
     } catch (error) {
-      this.ctx.logger.error("写入缓存出错:", error);
+      this.ctx.logger.error("写入数据出错:", error);
     }
   }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chat-analyse",
   "description": "聊天记录分析",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "contributors": [
     "Yis_Rime <yis_rime@outlook.com>"
   ],