koishi-plugin-bind-bot 2.2.9 → 2.4.0

package/lib/repositories/mcidbind.repository.js

@@ -2,171 +2,156 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCIDBINDRepository = void 0;
 const helpers_1 = require("../utils/helpers");
+const TABLE = 'user';
+const DATE_FIELDS = ['lastModified', 'usernameLastChecked', 'lastActiveTime'];
+function deserialize(row) {
+    if (!row)
+        return row;
+    for (const field of DATE_FIELDS) {
+        if (row[field] && typeof row[field] === 'string') {
+            row[field] = new Date(row[field]);
+        }
+    }
+    return row;
+}
+function serializeDates(data) {
+    const out = { ...data };
+    for (const field of DATE_FIELDS) {
+        if (out[field] instanceof Date) {
+            out[field] = out[field].toISOString();
+        }
+    }
+    return out;
+}
 /**
  * MCIDBIND 数据仓储类
- * 封装所有 MCIDBIND 表的数据库操作
+ * 通过 Supabase REST API 操作 user 表
  */
 class MCIDBINDRepository {
-    ctx;
+    supabase;
     logger;
-    constructor(ctx, logger) {
-        this.ctx = ctx;
+    constructor(supabase, logger) {
+        this.supabase = supabase;
         this.logger = logger;
     }
-    /**
-     * 根据 QQ 号查询绑定信息
-     * @param qqId QQ号（已规范化）
-     * @returns 绑定信息或 null
-     */
     async findByQQId(qqId) {
         try {
             this.logger.debug('数据库', `查询QQ(${qqId})的绑定信息`);
-            const binds = await this.ctx.database.get('mcidbind', { qqId });
-            return binds.length > 0 ? binds[0] : null;
+            const rows = await this.supabase.get(TABLE, `qqId=eq.${qqId}&limit=1`);
+            return rows.length > 0 ? deserialize(rows[0]) : null;
         }
         catch (error) {
             this.logger.error('数据库', `查询QQ(${qqId})绑定信息失败: ${error.message}`);
             return null;
         }
     }
-    /**
-     * 根据 MC 用户名查询绑定信息（精确匹配）
-     * @param mcUsername MC用户名
-     * @returns 绑定信息或 null
-     */
     async findByMCUsername(mcUsername) {
         try {
             this.logger.debug('数据库', `查询MC用户名(${mcUsername})的绑定信息`);
-            const binds = await this.ctx.database.get('mcidbind', { mcUsername });
-            return binds.length > 0 ? binds[0] : null;
+            const rows = await this.supabase.get(TABLE, `mcUsername=eq.${encodeURIComponent(mcUsername)}&limit=1`);
+            return rows.length > 0 ? deserialize(rows[0]) : null;
         }
         catch (error) {
             this.logger.error('数据库', `查询MC用户名(${mcUsername})绑定信息失败: ${error.message}`);
             return null;
         }
     }
-    /**
-     * 根据 MC 用户名查询绑定信息（不区分大小写）
-     * @param mcUsername MC用户名
-     * @returns 绑定信息或 null
-     */
     async findByUsernameIgnoreCase(mcUsername) {
         try {
             const normalizedInput = (0, helpers_1.normalizeUsername)(mcUsername, this.logger.getRawLogger());
             this.logger.debug('数据库', `查询MC用户名(${mcUsername} -> ${normalizedInput})的绑定信息（不区分大小写）`);
-            // 获取所有绑定记录，然后在应用层过滤（因为 Koishi 数据库不支持不区分大小写查询）
-            const allBinds = await this.ctx.database.get('mcidbind', {});
-            const match = allBinds.find(bind => bind.mcUsername && (0, helpers_1.normalizeUsername)(bind.mcUsername) === normalizedInput);
-            return match || null;
+            const rows = await this.supabase.get(TABLE, `mcUsername=ilike.${encodeURIComponent(mcUsername)}`);
+            const match = rows.find(bind => bind.mcUsername && (0, helpers_1.normalizeUsername)(bind.mcUsername) === normalizedInput);
+            return match ? deserialize(match) : null;
         }
         catch (error) {
             this.logger.error('数据库', `查询MC用户名(${mcUsername})绑定信息失败（不区分大小写）: ${error.message}`);
             return null;
         }
     }
-    /**
-     * 根据 MC UUID 查询绑定信息
-     * @param mcUuid MC UUID（可带或不带连字符）
-     * @returns 绑定信息或 null
-     */
     async findByUuid(mcUuid) {
         try {
-            // 规范化 UUID（移除连字符）
             const cleanUuid = mcUuid.replace(/-/g, '');
             this.logger.debug('数据库', `查询MC UUID(${cleanUuid})的绑定信息`);
-            // 先尝试精确匹配
-            let binds = await this.ctx.database.get('mcidbind', { mcUuid: cleanUuid });
-            if (binds.length > 0)
-                return binds[0];
-            // 尝试带连字符的格式
             const formattedUuid = `${cleanUuid.substring(0, 8)}-${cleanUuid.substring(8, 12)}-${cleanUuid.substring(12, 16)}-${cleanUuid.substring(16, 20)}-${cleanUuid.substring(20)}`;
-            binds = await this.ctx.database.get('mcidbind', { mcUuid: formattedUuid });
-            if (binds.length > 0)
-                return binds[0];
-            // 如果都没有，在应用层过滤（去除连字符后比较）
-            const allBinds = await this.ctx.database.get('mcidbind', {});
-            const match = allBinds.find(bind => bind.mcUuid && bind.mcUuid.replace(/-/g, '') === cleanUuid);
-            return match || null;
+            // 用 or 一次查两种格式
+            const rows = await this.supabase.get(TABLE, `or=(mcUuid.eq.${cleanUuid},mcUuid.eq.${formattedUuid})&limit=1`);
+            if (rows.length > 0)
+                return deserialize(rows[0]);
+            // 兜底：用 ilike 模糊匹配
+            const fallback = await this.supabase.get(TABLE, `mcUuid=ilike.*${cleanUuid}*&limit=1`);
+            if (fallback.length > 0)
+                return deserialize(fallback[0]);
+            return null;
         }
         catch (error) {
             this.logger.error('数据库', `查询MC UUID(${mcUuid})绑定信息失败: ${error.message}`);
             return null;
         }
     }
-    /**
-     * 根据 B站 UID 查询绑定信息
-     * @param buidUid B站UID
-     * @returns 绑定信息或 null
-     */
+    async validateBuidUid(uid) {
+        try {
+            this.logger.debug('数据库', `验证B站UID(${uid})是否存在`);
+            const rows = await this.supabase.get('events', `uid=eq.${uid}&uname=not.is.null&order=created_at.desc&limit=1&select=uid,uname`);
+            if (rows.length === 0)
+                return null;
+            return { uid: rows[0].uid.toString(), username: rows[0].uname };
+        }
+        catch (error) {
+            this.logger.error('数据库', `验证B站UID(${uid})失败: ${error.message}`);
+            return null;
+        }
+    }
     async findByBuidUid(buidUid) {
         try {
             this.logger.debug('数据库', `查询B站UID(${buidUid})的绑定信息`);
-            const binds = await this.ctx.database.get('mcidbind', { buidUid });
-            return binds.length > 0 ? binds[0] : null;
+            const rows = await this.supabase.get(TABLE, `buidUid=eq.${buidUid}&limit=1`);
+            return rows.length > 0 ? deserialize(rows[0]) : null;
         }
         catch (error) {
             this.logger.error('数据库', `查询B站UID(${buidUid})绑定信息失败: ${error.message}`);
             return null;
         }
     }
-    /**
-     * 获取所有绑定记录
-     * @param options 查询选项
-     * @returns 绑定记录列表
-     */
     async findAll(options) {
         try {
             this.logger.debug('数据库', `获取所有绑定记录${options?.limit ? ` (limit: ${options.limit})` : ''}`);
-            const records = await this.ctx.database.get('mcidbind', {}, options);
-            return records;
+            const query = options?.limit ? `limit=${options.limit}` : '';
+            const rows = await this.supabase.get(TABLE, query);
+            return rows.map(deserialize);
         }
         catch (error) {
             this.logger.error('数据库', `获取所有绑定记录失败: ${error.message}`);
             return [];
         }
     }
-    /**
-     * 根据标签查询绑定记录
-     * @param tag 标签名称
-     * @returns 包含该标签的绑定记录列表
-     */
     async findByTag(tag) {
         try {
             this.logger.debug('数据库', `查询包含标签"${tag}"的绑定记录`);
-            const allRecords = await this.ctx.database.get('mcidbind', {});
-            return allRecords.filter(record => record.tags && record.tags.includes(tag));
+            const rows = await this.supabase.get(TABLE, `tags=cs.${encodeURIComponent(JSON.stringify([tag]))}`);
+            return rows.map(deserialize);
         }
         catch (error) {
             this.logger.error('数据库', `查询标签"${tag}"的绑定记录失败: ${error.message}`);
             return [];
         }
     }
-    /**
-     * 创建新的绑定记录
-     * @param data 绑定数据
-     * @returns 创建的记录
-     */
     async create(data) {
         try {
             this.logger.debug('数据库', `创建QQ(${data.qqId})的绑定记录`);
-            const created = await this.ctx.database.create('mcidbind', data);
+            const created = await this.supabase.post(TABLE, serializeDates(data));
             this.logger.info('数据库', `成功创建QQ(${data.qqId})的绑定记录`, true);
-            return created;
+            return deserialize(created);
         }
         catch (error) {
             this.logger.error('数据库', `创建QQ(${data.qqId})绑定记录失败: ${error.message}`);
             throw error;
         }
     }
-    /**
-     * 更新绑定记录（部分字段）
-     * @param qqId QQ号
-     * @param data 要更新的字段
-     */
     async update(qqId, data) {
         try {
             this.logger.debug('数据库', `更新QQ(${qqId})的绑定记录`);
-            await this.ctx.database.set('mcidbind', { qqId }, data);
+            await this.supabase.patch(TABLE, `qqId=eq.${qqId}`, serializeDates(data));
             this.logger.info('数据库', `成功更新QQ(${qqId})的绑定记录`, true);
         }
         catch (error) {
@@ -174,49 +159,35 @@ class MCIDBINDRepository {
             throw error;
         }
     }
-    /**
-     * 删除绑定记录
-     * @param qqId QQ号
-     * @returns 删除的记录数
-     */
     async delete(qqId) {
         try {
             this.logger.debug('数据库', `删除QQ(${qqId})的绑定记录`);
-            const result = await this.ctx.database.remove('mcidbind', { qqId });
-            this.logger.info('数据库', `成功删除QQ(${qqId})的绑定记录（删除${result.removed}条）`, true);
-            return result.removed;
+            const removed = await this.supabase.del(TABLE, `qqId=eq.${qqId}`);
+            this.logger.info('数据库', `成功删除QQ(${qqId})的绑定记录（删除${removed}条）`, true);
+            return removed;
         }
         catch (error) {
             this.logger.error('数据库', `删除QQ(${qqId})绑定记录失败: ${error.message}`);
             throw error;
         }
     }
-    /**
-     * 删除所有绑定记录
-     * @returns 删除的记录数
-     */
     async deleteAll() {
         try {
             this.logger.debug('数据库', '删除所有绑定记录');
-            const result = await this.ctx.database.remove('mcidbind', {});
-            this.logger.info('数据库', `成功删除所有绑定记录（删除${result.removed}条）`, true);
-            return result.removed;
+            const removed = await this.supabase.del(TABLE, 'qqId=not.is.null');
+            this.logger.info('数据库', `成功删除所有绑定记录（删除${removed}条）`, true);
+            return removed;
         }
         catch (error) {
             this.logger.error('数据库', `删除所有绑定记录失败: ${error.message}`);
             throw error;
         }
     }
-    /**
-     * 批量创建绑定记录
-     * @param records 绑定记录列表
-     */
     async batchCreate(records) {
         try {
             this.logger.debug('数据库', `批量创建${records.length}条绑定记录`);
-            for (const record of records) {
-                await this.ctx.database.create('mcidbind', record);
-            }
+            const serialized = records.map(r => serializeDates(r));
+            await this.supabase.postMany(TABLE, serialized);
             this.logger.info('数据库', `成功批量创建${records.length}条绑定记录`, true);
         }
         catch (error) {
@@ -224,11 +195,6 @@ class MCIDBINDRepository {
             throw error;
         }
     }
-    /**
-     * 为用户添加标签
-     * @param qqId QQ号
-     * @param tag 标签名称
-     */
     async addTag(qqId, tag) {
         try {
             const bind = await this.findByQQId(qqId);
@@ -247,11 +213,6 @@ class MCIDBINDRepository {
             throw error;
         }
     }
-    /**
-     * 为用户移除标签
-     * @param qqId QQ号
-     * @param tag 标签名称
-     */
     async removeTag(qqId, tag) {
         try {
             const bind = await this.findByQQId(qqId);
@@ -271,11 +232,6 @@ class MCIDBINDRepository {
             throw error;
         }
     }
-    /**
-     * 为用户添加白名单服务器
-     * @param qqId QQ号
-     * @param serverId 服务器ID
-     */
     async addWhitelist(qqId, serverId) {
         try {
             const bind = await this.findByQQId(qqId);
@@ -294,11 +250,6 @@ class MCIDBINDRepository {
             throw error;
         }
     }
-    /**
-     * 为用户移除白名单服务器
-     * @param qqId QQ号
-     * @param serverId 服务器ID
-     */
     async removeWhitelist(qqId, serverId) {
         try {
             const bind = await this.findByQQId(qqId);
@@ -318,15 +269,11 @@ class MCIDBINDRepository {
             throw error;
         }
     }
-    /**
-     * 获取所有管理员
-     * @returns 管理员列表
-     */
     async findAllAdmins() {
         try {
             this.logger.debug('数据库', '获取所有管理员');
-            const allRecords = await this.ctx.database.get('mcidbind', {});
-            return allRecords.filter(record => record.isAdmin);
+            const rows = await this.supabase.get(TABLE, 'isAdmin=eq.true');
+            return rows.map(deserialize);
         }
         catch (error) {
             this.logger.error('数据库', `获取所有管理员失败: ${error.message}`);

package/lib/services/api.service.d.ts

@@ -1,15 +1,14 @@
 import { LoggerService } from '../utils/logger';
-import type { MojangProfile, ZminfoUser } from '../types';
+import type { MojangProfile } from '../types';
 /**
  * API 服务层
- * 统一管理外部 API 调用（Mojang API、ZMINFO API 等）
+ * 统一管理外部 API 调用（Mojang API、Bilibili 官方 API 等）
  */
 export declare class ApiService {
     private logger;
     private config;
     private cookieString;
     constructor(logger: LoggerService, config: {
-        zminfoApiUrl: string;
         SESSDATA?: string;
     });
     /**
@@ -49,12 +48,6 @@ export declare class ApiService {
         name: string;
         mid: number;
     } | null>;
-    /**
-     * 验证 B 站 UID 是否存在
-     * @param buid B站UID
-     * @returns ZminfoUser 或 null
-     */
-    validateBUID(buid: string): Promise<ZminfoUser | null>;
     /**
      * 获取 MC 头图 URL (Crafatar)
      * @param uuid MC UUID

package/lib/services/api.service.js

@@ -7,7 +7,7 @@ exports.ApiService = void 0;
 const axios_1 = __importDefault(require("axios"));
 /**
  * API 服务层
- * 统一管理外部 API 调用（Mojang API、ZMINFO API 等）
+ * 统一管理外部 API 调用（Mojang API、Bilibili 官方 API 等）
  */
 class ApiService {
     logger;
@@ -260,44 +260,6 @@ class ApiService {
             return null;
         }
     }
-    // =========== ZMINFO API ===========
-    /**
-     * 验证 B 站 UID 是否存在
-     * @param buid B站UID
-     * @returns ZminfoUser 或 null
-     */
-    async validateBUID(buid) {
-        try {
-            if (!buid || !/^\d+$/.test(buid)) {
-                this.logger.warn('B站账号验证', `无效的B站UID格式: ${buid}`);
-                return null;
-            }
-            this.logger.debug('B站账号验证', `验证B站UID: ${buid}`);
-            const response = await axios_1.default.get(`${this.config.zminfoApiUrl}/api/user/${buid}`, {
-                timeout: 10000,
-                headers: {
-                    'User-Agent': 'Koishi-MCID-Bot/1.0'
-                }
-            });
-            if (response.data.success && response.data.data && response.data.data.user) {
-                const user = response.data.data.user;
-                this.logger.debug('B站账号验证', `B站UID ${buid} 验证成功: ${user.username}`);
-                return user;
-            }
-            else {
-                this.logger.warn('B站账号验证', `B站UID ${buid} 不存在或API返回失败: ${response.data.message}`);
-                return null;
-            }
-        }
-        catch (error) {
-            if (error.response?.status === 404) {
-                this.logger.warn('B站账号验证', `B站UID ${buid} 不存在`);
-                return null;
-            }
-            this.logger.error('B站账号验证', `验证B站UID ${buid} 时出错: ${error.message}`);
-            throw new Error(`无法验证B站UID: ${error.message}`);
-        }
-    }
     // =========== 工具方法 ===========
     /**
      * 获取 MC 头图 URL (Crafatar)

package/lib/services/database.service.d.ts

@@ -1,7 +1,7 @@
 import { Context } from 'koishi';
 import { LoggerService } from '../utils/logger';
 import { MCIDBINDRepository } from '../repositories/mcidbind.repository';
-import type { MCIDBIND, ZminfoUser } from '../types';
+import type { MCIDBIND } from '../types';
 /**
  * 数据库服务层
  * 统一管理数据库操作，包括 MC 绑定和 BUID 绑定的 CRUD
@@ -43,12 +43,19 @@ export declare class DatabaseService {
     checkBuidExists(buid: string, currentUserId?: string): Promise<boolean>;
     /**
      * 创建或更新 B 站账号绑定
+     * 只写入 buidUid 和 buidUsername，详细字段由数据库触发器填充
      */
-    createOrUpdateBuidBind(userId: string, buidUser: ZminfoUser): Promise<boolean>;
+    createOrUpdateBuidBind(userId: string, buidUser: {
+        uid: string;
+        username: string;
+    }): Promise<boolean>;
     /**
-     * 仅更新 B 站信息，不更新绑定时间（用于查询时刷新数据）
+     * 仅更新 B 站用户名，不更新绑定时间（用于昵称同步等场景）
+     * 详细字段（guardLevel, medal等）由数据库触发器自动维护
      */
-    updateBuidInfoOnly(userId: string, buidUser: ZminfoUser): Promise<boolean>;
+    updateBuidInfoOnly(userId: string, buidUser: {
+        username: string;
+    }): Promise<boolean>;
     /**
      * 解绑 B 站账号（只清空 B 站字段，保留 MC 绑定）
      */

package/lib/services/database.service.js

@@ -254,6 +254,7 @@ class DatabaseService {
     }
     /**
      * 创建或更新 B 站账号绑定
+     * 只写入 buidUid 和 buidUsername，详细字段由数据库触发器填充
      */
     async createOrUpdateBuidBind(userId, buidUser) {
         try {
@@ -271,18 +272,8 @@ class DatabaseService {
             // 查询是否已存在绑定记录
             let bind = await this.getMcBindByQQId(normalizedQQId);
             const updateData = {
-                buidUid: buidUser.uid.toString(), // 转换为字符串存储
+                buidUid: buidUser.uid.toString(),
                 buidUsername: buidUser.username,
-                guardLevel: buidUser.guard_level || 0,
-                guardLevelText: buidUser.guard_level_text || '',
-                maxGuardLevel: buidUser.max_guard_level || 0,
-                maxGuardLevelText: buidUser.max_guard_level_text || '',
-                medalName: buidUser.medal?.name || '',
-                medalLevel: buidUser.medal?.level || 0,
-                wealthMedalLevel: buidUser.wealthMedalLevel || 0,
-                lastActiveTime: buidUser.last_active_time
-                    ? new Date(buidUser.last_active_time)
-                    : new Date(),
                 lastModified: new Date()
             };
             if (bind) {
@@ -315,7 +306,8 @@ class DatabaseService {
         }
     }
     /**
-     * 仅更新 B 站信息，不更新绑定时间（用于查询时刷新数据）
+     * 仅更新 B 站用户名，不更新绑定时间（用于昵称同步等场景）
+     * 详细字段（guardLevel, medal等）由数据库触发器自动维护
      */
     async updateBuidInfoOnly(userId, buidUser) {
         try {
@@ -330,19 +322,9 @@ class DatabaseService {
                 this.logger.warn('B站账号信息更新', `QQ(${normalizedQQId})没有绑定记录，无法更新B站信息`);
                 return false;
             }
-            // 仅更新B站相关字段，不更新lastModified
-            const updateData = {
-                buidUsername: buidUser.username,
-                guardLevel: buidUser.guard_level || 0,
-                guardLevelText: buidUser.guard_level_text || '',
-                maxGuardLevel: buidUser.max_guard_level || 0,
-                maxGuardLevelText: buidUser.max_guard_level_text || '',
-                medalName: buidUser.medal?.name || '',
-                medalLevel: buidUser.medal?.level || 0,
-                wealthMedalLevel: buidUser.wealthMedalLevel || 0,
-                lastActiveTime: buidUser.last_active_time ? new Date(buidUser.last_active_time) : new Date()
-            };
-            await this.mcidbindRepo.update(normalizedQQId, updateData);
+            await this.mcidbindRepo.update(normalizedQQId, {
+                buidUsername: buidUser.username
+            });
             this.logger.info('B站账号信息更新', `刷新信息: QQ=${normalizedQQId}, B站UID=${bind.buidUid}, 用户名=${buidUser.username}`, true);
             return true;
         }
@@ -386,9 +368,7 @@ class DatabaseService {
                     buidUid: null,
                     buidUsername: null,
                     guardLevel: 0,
-                    guardLevelText: '',
                     maxGuardLevel: 0,
-                    maxGuardLevelText: '',
                     medalName: '',
                     medalLevel: 0,
                     wealthMedalLevel: 0,

package/lib/services/nickname.service.d.ts

@@ -1,6 +1,5 @@
 import { Session } from 'koishi';
 import { LoggerService } from '../utils/logger';
-import type { ZminfoUser } from '../types';
 /**
  * 群昵称管理服务
  * 负责自动设置和验证群昵称
@@ -9,26 +8,27 @@ export declare class NicknameService {
     private logger;
     private config;
     private normalizeQQId;
-    private validateBUID;
     private getBilibiliOfficialUserInfo;
     private updateBuidInfoOnly;
     constructor(logger: LoggerService, config: {
         autoNicknameGroupId: string;
-    }, normalizeQQId: (userId: string) => string, validateBUID: (buid: string) => Promise<ZminfoUser | null>, getBilibiliOfficialUserInfo: (uid: string) => Promise<{
+    }, normalizeQQId: (userId: string) => string, getBilibiliOfficialUserInfo: (uid: string) => Promise<{
         name: string;
         mid: number;
-    } | null>, updateBuidInfoOnly: (userId: string, buidUser: ZminfoUser) => Promise<boolean>);
+    } | null>, updateBuidInfoOnly: (userId: string, buidUser: {
+        username: string;
+    }) => Promise<boolean>);
     /**
      * 检查群昵称格式是否正确
      */
     checkNicknameFormat(nickname: string, buidUsername: string, mcUsername: string | null): boolean;
     /**
-     * 使用四层判断逻辑获取最准确的B站用户名
-     * 优先级：官方API > ZMINFO > 数据库
+     * 获取最准确的B站用户名
+     * 优先级：官方API > 数据库
      */
     private getLatestBuidUsername;
     /**
-     * 同步数据库中的B站用户信息
+     * 同步数据库中的B站用户名
      */
     private syncDatabaseIfNeeded;
     /**