node-karin 0.10.0 → 0.10.2

package/lib/db/redis/redis_level.js

@@ -0,0 +1,287 @@
+import { Level } from 'level';
+export default class RedisLevel {
+    #level;
+    #expireMap;
+    id;
+    constructor() {
+        const path = process.cwd() + '/data/db/RedisLevel';
+        this.#level = new Level(path, { valueEncoding: 'json' });
+        /**
+         * @type {'RedisLevel'} 唯一标识符 用于区分不同的数据库
+         */
+        this.id = 'RedisLevel';
+        /**
+         * 过期时间映射表
+         * @type {Map<string, number>} 键: 值 (过期时间)
+         */
+        this.#expireMap = new Map();
+        /**
+         * 开启过期时间处理
+         */
+        this.#expireHandle();
+    }
+    /**
+     * 过期时间处理 每分钟检查一次
+     */
+    async #expireHandle() {
+        setInterval(async () => {
+            const now = Date.now();
+            // 获取代理对象的键值对数组
+            const entries = Array.from(this.#expireMap.entries());
+            for (const [key, expire] of entries) {
+                if (expire < now) {
+                    await this.#level.del(key);
+                    this.#expireMap.delete(key); // 通过代理的方式删除键值对
+                }
+            }
+        }, 60000);
+        /**
+         * 对expireMap进行代理 实现持久化 每次触发都保存到数据库
+         */
+        const handler = {
+            get: function (target, prop, receiver) {
+                if (prop === 'get' || prop === 'entries') {
+                    return function (...args) {
+                        const reflect = Reflect.get(target, prop).apply(target, args);
+                        return typeof reflect === 'function' ? reflect.bind(target) : reflect;
+                    };
+                }
+                const reflect = Reflect.get(target, prop, receiver);
+                return typeof reflect === 'function' ? reflect.bind(target) : reflect;
+            },
+            set: function (target, key, value) {
+                target.set(key, value);
+                // 修改后持久化到数据库
+                const reflect = Reflect.set(target, key, value);
+                return typeof reflect === 'function' ? reflect.bind(target) : reflect;
+            },
+            deleteProperty: function (target, key) {
+                Reflect.deleteProperty(target, key);
+                // 删除后持久化到数据库
+                const reflect = Reflect.deleteProperty(target, key);
+                return typeof reflect === 'function' ? reflect.bind(target) : reflect;
+            },
+        };
+        this.#expireMap = new Proxy(this.#expireMap, handler);
+    }
+    /**
+     * get 获取数据
+     * @param {string} key 键
+     * @returns {Promise<string>|Error} 数据
+     */
+    async get(key) {
+        try {
+            /** 先查过期时间 */
+            const expire = this.#expireMap.get(key);
+            if (expire && expire < Date.now()) {
+                await this.#level.del(key);
+                this.#expireMap.delete(key);
+                return null;
+            }
+            return await this.#level.get(key);
+        }
+        catch (error) {
+            if (error.notFound)
+                return null;
+            throw error;
+        }
+    }
+    /**
+     * set 设置数据
+     * @param key 键
+     * @param value 值
+     * @param options 选项
+     */
+    async set(key, value, options) {
+        if (options && options.EX) {
+            this.#expireMap.set(key, Date.now() + options.EX * 1000);
+        }
+        return await this.#level.put(key, value);
+    }
+    /**
+     * del 删除数据
+     * @param key 键
+     */
+    async del(key) {
+        this.#expireMap.delete(key);
+        return await this.#level.del(key);
+    }
+    /**
+     * keys 获取所有键
+     * @param prefix 前缀
+     */
+    async keys(prefix = '') {
+        /** 去掉末尾的* */
+        prefix = prefix.replace(/\*$/, '');
+        const list = await this.#level.keys({ gte: prefix, lt: `${prefix}\xFF` }).all();
+        this.#checkKeys(list);
+        return list;
+    }
+    /**
+     * 给一个kyes 检查是否过期
+     * @param keys 键数组
+     */
+    async #checkKeys(keys) {
+        for (const key of keys) {
+            const expire = this.#expireMap.get(key);
+            if (expire && expire < Date.now()) {
+                await this.#level.del(key);
+                this.#expireMap.delete(key);
+            }
+        }
+    }
+    /**
+     * incr 递增数据
+     * @param {string} key 键
+     * @returns {Promise<number>|Error}
+     */
+    async incr(key) {
+        let value = Number(await this.get(key));
+        if (value === null) {
+            value = 0;
+        }
+        else {
+            value = Number(value);
+            if (isNaN(value))
+                throw new Error('Value is not a number');
+        }
+        value += 1;
+        await this.set(key, value.toString());
+        return value;
+    }
+    /**
+     * decr 递减数据
+     * @param {string} key 键
+     * @returns {Promise<number>|Error}
+     */
+    async decr(key) {
+        let value = Number(await this.get(key));
+        if (value === null) {
+            value = 0;
+        }
+        else {
+            value = Number(value);
+            if (isNaN(value))
+                throw new Error('Value is not a number');
+        }
+        value -= 1;
+        await this.set(key, value.toString());
+        return value;
+    }
+    /**
+     * expire 设置过期时间
+     * @param {string} key 键
+     * @param seconds 过期时间 单位秒
+     * @returns {Promise<number>|Error}
+     */
+    async expire(key, seconds) {
+        this.#expireMap.set(key, Date.now() + seconds * 1000);
+        return seconds;
+    }
+    /**
+     * ttl 获取过期时间
+     * @param {string} key 键
+     * @returns {Promise<number>|Error}
+     */
+    async ttl(key) {
+        const expire = this.#expireMap.get(key);
+        if (expire) {
+            return Math.ceil((expire - Date.now()) / 1000);
+        }
+        return -2;
+    }
+    /**
+     * setEx 设置数据并设置过期时间
+     * @param {string} key 键
+     * @param seconds 过期时间 单位秒
+     * @param {string} value 值
+     * @returns {Promise<void>|Error}
+     */
+    async setEx(key, seconds, value) {
+        this.#expireMap.set(key, Date.now() + seconds * 1000);
+        return await this.#level.put(key, value);
+    }
+    /**
+     * exists 判断键是否存在
+     * @param {string} key 键
+     * @returns {Promise<number>|Error}
+     */
+    async exists(key) {
+        const value = await this.get(key);
+        return value === null ? 0 : 1;
+    }
+    /**
+     * zAdd 有序集合添加元素
+     * @param {string} key 键
+     * @param {object} data 数据
+     * @param data.score 分数
+     * @param {string} data.value 值
+     */
+    async zAdd(key, { score, value }) {
+        const set = await this.get(key);
+        const arr = (set ? JSON.parse(set) : []);
+        arr.push({ score, value });
+        arr.sort((a, b) => a.score - b.score);
+        await this.set(key, JSON.stringify(arr));
+    }
+    /**
+     * zRem 有序集合删除元素
+     * @param {string} key 键
+     * @param {string} value 值
+     */
+    async zRem(key, value) {
+        const set = await this.get(key);
+        if (set === null)
+            return;
+        let arr = JSON.parse(set);
+        arr = arr.filter((item) => item.value !== value);
+        await this.set(key, JSON.stringify(arr));
+    }
+    /**
+     * zIncrBy 有序集合分数递增
+     * @param {string} key 键
+     * @param increment 递增值
+     * @param {string} value 值
+     * @returns {Promise<number>|Error}
+     */
+    async zIncrBy(key, increment, value) {
+        const set = await this.get(key);
+        if (set === null)
+            throw new Error('Set does not exist');
+        const arr = JSON.parse(set);
+        const item = arr.find((item) => item.value === value);
+        if (item)
+            item.score += increment;
+        arr.sort((a, b) => a.score - b.score);
+        await this.set(key, JSON.stringify(arr));
+        return item.score;
+    }
+    /**
+     * zRangeByScore 有序集合根据分数范围获取元素
+     * @param {string} key 键
+     * @param min 最小分数
+     * @param max 最大分数
+     * @returns {Promise<string[]>|Error}
+     */
+    async zRangeByScore(key, min, max) {
+        const set = await this.get(key);
+        if (set === null)
+            return [];
+        const arr = JSON.parse(set);
+        return arr.filter((item) => item.score >= min && item.score <= max).map((item) => item.value);
+    }
+    /**
+     * zScore 有序集合获取元素分数
+     * @param {string} key 键
+     * @param {string} value 值
+     * @returns {Promise<number>|Error}
+     */
+    async zScore(key, value) {
+        const set = await this.get(key);
+        if (set === null)
+            return null;
+        const arr = JSON.parse(set);
+        const item = arr.find((item) => item.value === value);
+        return item ? item.score : null;
+    }
+}

package/lib/event/{event.handler.d.ts → handler/base.d.ts}

@@ -1,5 +1,5 @@
-import { GroupCfg, KarinEventTypes, AllListenEvent, PluginRule } from '../types/index.js';
-export default class EventHandler {
+import { GroupCfg, KarinEventTypes, AllListenEvent, PluginRule } from '../../types/index.js';
+export declare class EventBaseHandler {
     e: KarinEventTypes;
     config: GroupCfg | {};
     /**

package/lib/event/handler/base.js

@@ -0,0 +1,173 @@
+import { listener } from '../../core/index.js';
+import { review } from './review.js';
+import { segment, common, logger, config } from '../../utils/index.js';
+export class EventBaseHandler {
+    e;
+    config;
+    /**
+     * - 是否打印群消息日志
+     */
+    GroupMsgPrint;
+    /**
+     * 处理事件，加入自定义字段
+     */
+    constructor(e) {
+        this.e = e;
+        this.config = {};
+        this.GroupMsgPrint = false;
+        /** 加入e.bot */
+        !this.e.bot && Object.defineProperty(this.e, 'bot', { value: listener.getBot(this.e.self_id) });
+        if (this.e.group_id)
+            this.config = config.group(this.e.group_id, this.e);
+    }
+    /**
+     * 事件处理
+     */
+    review() {
+        /** 检查CD */
+        if (!review.CD(this.e, this.config)) {
+            logger.debug('[消息拦截] 正在冷却中');
+            return true;
+        }
+        /** 检查群聊黑白名单 */
+        if (!review.GroupEnable(this.e)) {
+            logger.debug('[消息拦截] 未通过群聊黑白名单检查');
+            return true;
+        }
+        /** 检查用户黑白名单 */
+        if (!review.UserEnable(this.e)) {
+            logger.debug('[消息拦截] 未通过用户黑白名单检查');
+            return true;
+        }
+        /** 都通过了 */
+        return false;
+    }
+    /**
+     * 处理私聊功能 功能开启返回true
+     */
+    private() {
+        /** 检查私聊是否开启 */
+        if (this.e.user_id !== 'input' && this.e.isPrivate && !review.Private()) {
+            /** 用户处于白名单 */
+            if (config.Config?.private?.white_list?.includes(String(this.e.user_id)))
+                return true;
+            /** 不处于白名单 检查是否存在提示词 */
+            if (config.Config?.private?.tips)
+                this.e.reply(config.Config.private.tips);
+            logger.debug('[消息拦截] 私聊功能未开启');
+            return false;
+        }
+        return true;
+    }
+    /**
+     * 根据事件类型过滤事件
+     */
+    filtEvent(event) {
+        /** 事件映射表 */
+        const eventMap = {
+            message: () => `message.${this.e.sub_event}`,
+            message_sent: () => `message_sent.${this.e.sub_event}`,
+            meta_event: () => `message.${this.e.sub_event}`,
+            notice: () => `notice.${this.e.sub_event}`,
+            request: () => `request.${this.e.sub_event}`,
+        };
+        const eventType = eventMap[this.e.event]();
+        return eventType.includes(event);
+    }
+    /**
+     * 判断权限
+     */
+    filterPermission(permission) {
+        if (!permission || permission === 'all')
+            return true;
+        if (permission === 'master') {
+            if (!this.e.isMaster) {
+                this.e.reply('暂无权限，只有主人才能操作');
+                return false;
+            }
+            return true;
+        }
+        if (permission === 'admin') {
+            if (!this.e.isMaster && !this.e.isAdmin) {
+                this.e.reply('暂无权限，只有管理员才能操作');
+                return false;
+            }
+            return true;
+        }
+        if (this.e.isGroup) {
+            const list = {
+                'group.owner': {
+                    role: 'owner',
+                    name: '群主',
+                },
+                'group.admin': {
+                    role: 'admin',
+                    name: '群管理员',
+                },
+            };
+            const role = list[permission];
+            if (!role)
+                return true;
+            if (role.role === 'owner' && this.e.sender?.role === 'owner')
+                return true;
+            if (role.role === 'admin' && (this.e.sender?.role === 'owner' || this.e.sender?.role === 'admin'))
+                return true;
+            this.e.reply(`暂无权限，只有${role.name}才能操作`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * 快速回复
+     */
+    reply() {
+        /**
+         * 快速回复
+         * @param elements 回复内容
+         * @param options 回复选项
+         */
+        this.e.reply = async (elements = '', options = { reply: false, recallMsg: 0, at: false, retry_count: 1 }) => {
+            const message = common.makeMessage(elements);
+            const { reply = false, recallMsg = 0, at, retry_count = 1 } = options;
+            /** 加入at */
+            if (at && this.e.isGroup)
+                message.unshift(segment.at(this.e.user_id));
+            /** 加入引用回复 */
+            if (reply && 'message_id' in this.e)
+                message.unshift(segment.reply(this.e.message_id));
+            /** 先发 提升速度 */
+            const result = this.e.replyCallback(message, retry_count);
+            const ReplyLog = common.makeMessageLog(message);
+            if (this.e.isGroup) {
+                review.GroupMsgPrint(this.e) && logger.bot('info', this.e.self_id, `${logger.green(`Send Group ${this.e.group_id}: `)}${ReplyLog}`);
+            }
+            else {
+                this.e.self_id !== 'input' && logger.bot('info', this.e.self_id, `${logger.green(`Send private ${this.e.user_id}: `)}${ReplyLog}`);
+            }
+            const request = {
+                message_id: '',
+                message_time: 0,
+                raw_data: undefined,
+            };
+            try {
+                listener.emit('karin:count:send', 1);
+                /** 取结果 */
+                const Res = await result;
+                request.message_id = Res.message_id || '';
+                request.message_time = Res.message_time || Date.now();
+                request.raw_data = Res.raw_data || undefined;
+                logger.bot('debug', this.e.self_id, `回复消息结果:${JSON.stringify(request)}`);
+            }
+            catch (error) {
+                logger.bot('error', this.e.self_id, `回复消息失败:${ReplyLog}`);
+                logger.bot('error', this.e.self_id, error.stack || error.message || JSON.stringify(error));
+            }
+            /** 快速撤回 */
+            if (recallMsg > 0 && request.message_id) {
+                setTimeout(() => this.e.bot.RecallMessage(this.e.contact, request.message_id), recallMsg * 1000);
+            }
+            return request;
+        };
+        Object.freeze(this.e.reply);
+    }
+}

package/lib/event/{message.handler.d.ts → handler/message.d.ts}

@@ -1,9 +1,9 @@
-import EventHandler from './event.handler.js';
-import { KarinMessageType } from '../types/index.js';
+import { EventBaseHandler } from './base.js';
+import { KarinMessageType } from '../../types/index.js';
 /**
  * 消息事件
  */
-export declare class MessageHandler extends EventHandler {
+export declare class MessageHandler extends EventBaseHandler {
     e: KarinMessageType;
     /**
      * - 是否打印群消息日志