mirai-js 2.8.3 → 2.8.5

package/srcold/Middleware.js

@@ -0,0 +1,657 @@
+const responseFirendRequest = require('./core/responseFirendRequest');
+const responseMemberJoinRequest = require('./core/responseMemberJoinRequest');
+const responseBotInvitedJoinGroupRequest = require('./core/responseBotInvitedJoinGroupRequest');
+
+/**
+ * @description 为事件处理器提供中间件
+ * @use 在 MiddleWare 的实例上链式调用需要的中间件方法，最后
+ * 调用 done 并传入一个回调函数，该函数将在中间件结束后被调用
+ */
+class Middleware {
+    constructor() {
+        this.middleware = [];
+        this.catcher = undefined;
+    }
+
+    /**
+     * @description 自动重新登陆
+     * @param {string} baseUrl  mirai-api-http server 的地址
+     * @param {string} verifyKey  mirai-api-http server 设置的 verifyKey
+     * @param {string} password 欲重新登陆的 qq 密码
+     */
+    autoReLogin({ password }) {
+        this.middleware.push(async (data, next) => {
+            try {
+                await data.bot.sendCommand({
+                    command: ['/login', data.qq, password],
+                });
+                await data.bot.open();
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+
+        });
+        return this;
+    }
+
+    /**
+     * @description 自动重建 ws 连接
+     */
+    autoReconnection() {
+        this.middleware.push(async (data, next) => {
+            try {
+                await data.bot.open();
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 过滤出指定类型的消息，消息类型为 key，对应类型的
+     *              message 数组为 value，置于 data.classified
+     * @param {string[]} typeArr message 的类型，例如 Plain Image Voice
+     */
+    messageProcessor(typeArr) {
+        this.middleware.push(async (data, next) => {
+            try {
+                const result = {};
+                typeArr.forEach((type) => {
+                    result[type] = data.messageChain.filter((message) => message.type == type);
+                });
+                data.classified = result;
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+
+        });
+        return this;
+    }
+
+    /**
+     * @description 过滤出字符串类型的 message，并拼接在一起，置于 data.text
+     */
+    textProcessor() {
+        this.middleware.push(async (data, next) => {
+            try {
+                data.text = data.messageChain
+                    .filter((val) => val.type == 'Plain')
+                    .map((val) => val.text)
+                    .join('');
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 过滤出消息 id，置于 data.messageId
+     */
+    messageIdProcessor() {
+        this.middleware.push(async (data, next) => {
+            try {
+                data.messageId = Array.isArray(data.messageChain) ? data.messageChain[0]?.id : undefined;
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 过滤指定的群消息
+     * @param {number[]} groupArr 允许通过的群号数组
+     * @param {boolean}       allow    允许通过还是禁止通过
+     */
+    groupFilter(groupArr, allow = true) {
+        const groupSet = new Set(groupArr);
+
+        this.middleware.push(async (data, next) => {
+            try {
+                // 检查参数
+                if (!(data?.sender?.group?.id)) {
+                    throw new Error('Middleware.groupFilter 消息格式出错');
+                }
+
+                // 如果 id 在 set 里，根据 allow 判断是否交给下一个中间件处理
+                if (groupSet.has(data.sender.group.id)) {
+                    return allow && next();
+                }
+                !allow && await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 过滤指定的好友消息
+     * @param {number[]} friendArr 好友 qq 号数组
+     * @param {boolean}       allow     允许通过还是禁止通过
+     */
+    friendFilter(friendArr, allow = true) {
+        const groupSet = new Set(friendArr);
+
+        this.middleware.push(async (data, next) => {
+            try {
+                // 检查参数
+                if (!(data?.sender?.id)) {
+                    throw new Error('Middleware.friendFilter 消息格式出错');
+                }
+
+                // 如果 id 在 set 里，根据 allow 判断是否交给下一个中间件处理
+                if (groupSet.has(data.sender.id)) {
+                    return allow && await next();
+                }
+                !allow && await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 过滤指定群的群成员的消息
+     * @param {Map}     groupMemberMap 群和成员的 Map
+     * @param {boolean} allow          允许通过还是禁止通过
+     * 结构 { number => array[number], } key 为允许通过的群号，value 为该群允许通过的成员 qq
+     */
+    groupMemberFilter(groupMemberMap, allow = true) {
+        // 每个 qq 数组变成 Set
+        for (const group in groupMemberMap) {
+            groupMemberMap[group] = new Set(groupMemberMap[group]);
+        }
+
+        this.middleware.push(async (data, next) => {
+            try {
+                // 检查参数
+                if (!(data?.sender?.id)) {
+                    throw new Error('Middleware.friendFilter 消息格式出错');
+                }
+
+                // 检查是否是群消息
+                if (!(data.sender.group)) {
+                    return;
+                }
+
+                // 检查是否是允许通过的群成员，是则交给下一个中间件处理
+                if (data.sender.group.id in groupMemberMap &&
+                    groupMemberMap[data.sender.group.id].has(data.sender.id)) {
+                    return allow && await next();
+                }
+                !allow && await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 这是一个对话锁，保证群中同一成员不能在中途触发处理器
+     * @use 在你需要保护的过程结束后调用 data.unlock 即可
+     */
+    memberLock({ autoUnlock = false } = {}) {
+        const memberMap = {/* group -> memberSet */ };
+        this.middleware.push(async (data, next) => {
+            try {
+                // 检查参数
+                if (!data.sender?.group?.id) {
+                    throw new Error('Middleware.memberLock 消息格式出错');
+                }
+
+                // 若该 group 不存在对应的 Set，则添加
+                if (!(memberMap[data.sender?.group?.id] instanceof Set)) {
+                    memberMap[data.sender?.group?.id] = new Set();
+                }
+
+                // 是否正在对话
+                if (memberMap[data.sender?.group?.id].has(data.sender?.id)) {
+                    // 正在对话则返回
+                    return;
+                } else {
+                    // 未在对话，则加入对应的 Set，然后继续
+                    memberMap[data.sender?.group?.id].add(data.sender?.id);
+                    let locked = true;
+                    const unlock = () => {
+                        memberMap[data.sender?.group?.id].delete(data.sender?.id);
+                        locked = false;
+                    };
+                    data.unlock = unlock;
+
+                    // 等待下游中间件结束后 unlock
+                    await next();
+                    autoUnlock && locked && unlock();
+                }
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 这是一个对话锁，保证同一好友不能在中途触发处理器
+     * @use 在你需要保护的过程结束后调用 data.unlock 即可
+     */
+    friendLock({ autoUnlock = false } = {}) {
+        const friendSet = new Set();
+        this.middleware.push(async (data, next) => {
+            try {
+                // 检查参数
+                if (!data.sender?.id) {
+                    throw new Error('Middleware.memberLock 消息格式出错');
+                }
+
+                // 是否正在对话
+                if (friendSet.has(data.sender?.id)) {
+                    // 正在对话则返回
+                    return;
+                } else {
+                    // 未在对话，则加入 Set，然后继续
+                    friendSet.add(data.sender?.id);
+                    let locked = true;
+                    const unlock = () => {
+                        friendSet.delete(data.sender?.id);
+                        locked = false;
+                    };
+                    data.unlock = unlock;
+
+                    // 等待下游中间件结束后 unlock
+                    await next();
+                    autoUnlock && locked && unlock();
+                }
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 过滤包含指定 @ 信息的消息
+     * @param {number[]} atArr 必选，qq 号数组
+     * @param {boolean}       allow 可选，允许通过还是禁止通过
+     */
+    atFilter(friendArr, allow = true) {
+        const friendSet = new Set(friendArr);
+
+        this.middleware.push(async (data, next) => {
+            try {
+                // 检查参数
+                if (!(data?.messageChain)) {
+                    throw new Error('Middleware.atFilter 消息格式出错');
+                }
+
+                // 如果 id 在 set 里，根据 allow 判断是否交给下一个中间件处理
+                for (const message of data.messageChain) {
+                    if (message?.type == 'At' && friendSet.has(message?.target)) {
+                        return allow && await next();
+                    }
+                }
+                !allow && await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 用于 NewFriendRequestEvent 的中间件，经过该中间件后，将在 data 下放置三个方法
+     * agree、refuse、refuseAndAddBlacklist，调用后将分别进行好友请求的 同意、拒绝和拒绝并加入黑名单
+     */
+    friendRequestProcessor() {
+        this.middleware.push(async (data, next) => {
+            try {
+                // 事件类型
+                if (data.type != 'NewFriendRequestEvent') {
+                    throw new Error('Middleware.NewFriendRequestEvent 消息格式出错');
+                }
+
+                // ? baseUrl, sessionKey 放在内部获取，使用最新的实例状态
+                const baseUrl = data.bot.getBaseUrl();
+                const sessionKey = data.bot.getSessionKey();
+                const { eventId, fromId, groupId } = data;
+
+                // 同意
+                data.agree = async (message) => {
+                    await responseFirendRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 0,
+                    });
+                };
+
+                // 拒绝
+                data.refuse = async (message) => {
+                    await responseFirendRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 1,
+                    });
+                };
+
+                // 拒绝并加入黑名单
+                data.refuseAndAddBlacklist = async (message) => {
+                    await responseFirendRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 2,
+                    });
+                };
+
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 用于 MemberJoinRequestEvent 的中间件，经过该中间件后，将在 data 下放置五个方法
+     * agree                 同意
+     * refuse                拒绝
+     * ignore                忽略
+     * refuseAndAddBlacklist 拒绝并移入黑名单
+     * ignoreAndAddBlacklist 忽略并移入黑名单
+     */
+    memberJoinRequestProcessor() {
+        this.middleware.push(async (data, next) => {
+            try {
+                // 事件类型
+                if (data.type != 'MemberJoinRequestEvent') {
+                    throw new Error('Middleware.memberJoinRequestProcessor 消息格式出错');
+                }
+
+                // ? baseUrl, sessionKey 放在内部获取，使用最新的实例状态
+                const baseUrl = data.bot.getBaseUrl();
+                const sessionKey = data.bot.getSessionKey();
+                const { eventId, fromId, groupId } = data;
+
+                // 同意
+                data.agree = async (message) => {
+                    await responseMemberJoinRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 0,
+                    });
+                };
+
+                // 拒绝
+                data.refuse = async (message) => {
+                    await responseMemberJoinRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 1,
+                    });
+                };
+
+                // 忽略
+                data.ignore = async (message) => {
+                    await responseMemberJoinRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 2,
+                    });
+                };
+
+                // 拒绝并加入黑名单
+                data.refuseAndAddBlacklist = async (message) => {
+                    await responseMemberJoinRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 3,
+                    });
+                };
+
+                // 忽略并加入黑名单
+                data.ignoreAndAddBlacklist = async (message) => {
+                    await responseMemberJoinRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 4,
+                    });
+                };
+
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+
+    /**
+     * ! 自动同意时，不会触发该事件
+     * @description 用于 BotInvitedJoinGroupRequestEvent 的中间件，经过该中间件后，将在 data 下放置两个方法
+     * agree                 同意
+     * refuse                拒绝
+     */
+    invitedJoinGroupRequestProcessor() {
+        this.middleware.push(async (data, next) => {
+            try {
+                // 事件类型
+                if (data.type != 'BotInvitedJoinGroupRequestEvent') {
+                    throw new Error('Middleware.invitedJoinGroupRequestProcessor 消息格式出错');
+                }
+
+                // ? baseUrl, sessionKey 放在内部获取，使用最新的实例状态
+                const baseUrl = data.bot.getBaseUrl();
+                const sessionKey = data.bot.getSessionKey();
+                const { eventId, fromId, groupId } = data;
+
+                // 同意
+                data.agree = async (message) => {
+                    await responseBotInvitedJoinGroupRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 0,
+                    });
+                };
+
+                // 拒绝
+                data.refuse = async (message) => {
+                    await responseBotInvitedJoinGroupRequest({
+                        baseUrl, sessionKey, eventId, fromId, groupId,
+                        message, operate: 1,
+                    });
+                };
+
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description Waiter 的包装器，提供方便的同步 IO 方式
+     */
+    syncWrapper() {
+        this.middleware.push(async (data, next) => {
+            try {
+                // 事件类型
+                if (data.type != 'GroupMessage' && data.type != 'FriendMessage') {
+                    throw new Error('Middleware.syncWrapper 消息格式出错');
+                }
+                const watiForMessageChain = async (qq) => {
+                    qq = qq ?? data?.sender?.id;
+                    if (qq == undefined) {
+                        throw new Error('Middleware.syncWrapper 消息格式出错');
+                    }
+                    do {
+                        var { messageChain, id } = await data.bot?.waiter?.wait(data.type, ({ messageChain, sender: { id } }) => ({ messageChain, id })) ?? {};
+                    } while (qq != id);
+
+                    return messageChain;
+                };
+
+                const waitForText = async (qq) => {
+                    qq = qq ?? data?.sender?.id;
+                    if (qq == undefined) {
+                        throw new Error('Middleware.syncWrapper 消息格式出错');
+                    }
+                    do {
+                        var { text, id } = await data.bot?.waiter?.wait(data.type, new Middleware().textProcessor().done(({ text, sender: { id } }) => ({ text, id }))) ?? {};
+                    } while (qq != id);
+                    return text;
+                };
+
+                const waitForCustom = async (qq, processor) => {
+                    qq = qq ?? data?.sender?.id;
+                    if (qq == undefined) {
+                        throw new Error('Middleware.syncWrapper 消息格式出错');
+                    }
+                    do {
+                        var data = await data.bot?.waiter?.wait(data.type, new Middleware().textProcessor().done((data) => data));
+                    } while (qq != data?.sender?.id);
+                    return await processor(data);
+                };
+
+                data.waitFor = {
+                    groupMember: (qq = undefined) => {
+                        return {
+                            messageChain: () => watiForMessageChain(qq),
+                            text: () => waitForText(qq),
+                            custom: (processor) => waitForCustom(qq, processor),
+                        };
+                    },
+                    friend: (qq) => {
+                        return {
+                            messageChain: () => watiForMessageChain(qq),
+                            text: () => waitForText(qq),
+                            custom: (processor) => waitForCustom(qq, processor),
+                        };
+                    },
+                    messageChain: () => watiForMessageChain(data.sender.id),
+                    text: () => waitForText(data.sender.id),
+                    custom: (processor) => waitForCustom(data.sender.id, processor),
+                };
+
+                await next();
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+
+
+    /**
+     * @description 添加一个自定义中间件
+     * @param {function} callback (data, next) => void
+     */
+    use(callback) {
+        this.middleware.push(async (data, next) => {
+            // 捕获错误
+            try {
+                await callback(data, next);
+            } catch (error) {
+                if (this.catcher) {
+                    this.catcher(error);
+                } else {
+                    throw error;
+                }
+            }
+        });
+        return this;
+    }
+
+    /**
+     * @description 使用错误处理器
+     * @param {function} catcher 错误处理器 (err) => void
+     */
+    catch(catcher) {
+        this.catcher = catcher;
+        return this;
+    }
+
+    /**
+     * @description 生成一个带有中间件的事件处理器
+     * @param {function} callback 事件处理器
+     */
+    done(callback) {
+        return data => {
+            return new Promise(resolve => {
+                // 从右侧递归合并中间件链
+                this.middleware.reduceRight((next, middleware) => {
+                    return async () => resolve(await middleware(data, next));
+                }, async () => {
+                    // 最深层递归，即开发者提供的回调函数
+                    let returnVal = callback instanceof Function ? (await callback(data)) : undefined;
+
+                    // 异步返回
+                    resolve(returnVal);
+                })();
+            });
+        };
+
+    }
+}
+
+module.exports = { Middleware };

package/srcold/Waiter.d.ts

@@ -0,0 +1,13 @@
+import { EventType, Processor } from './BaseType';
+import { Bot } from './Bot';
+
+export class Waiter {
+    private bot: Bot;
+
+    /**
+     * @description 等待一次消息，经过开发者提供的处理器后返回到异步代码处
+     * @param eventType 事件类型
+     * @param callback  处理器，其返回值将被 resolve，传递到外部
+     */
+    wait(eventType: EventType, callback: Processor): Promise<any>;
+}

package/srcold/Waiter.js

@@ -0,0 +1,24 @@
+/**
+ * @description 每个 Bot 实例将维护一个 Waiter 实例，它用来同步等待一次用户输入
+ * @use 使用 bot.waiter
+ */
+class Waiter {
+    constructor(bot) {
+        this.bot = bot;
+    }
+
+    /**
+     * @description 等待一次消息，经过开发者提供的处理器后返回到异步代码处
+     * @param {string}   eventType 事件类型
+     * @param {function} callback  处理器，其返回值将被 resolve，传递到外部
+     */
+    async wait(eventType, callback) {
+        return new Promise(resolve => {
+            // 注册严格的一次事件，等待回调
+            this.bot.one(eventType, async data => resolve(await callback(data)), true);
+        });
+    }
+
+}
+
+module.exports = { Waiter };