node-karin 0.9.0 → 0.10.1

package/lib/core/plugin/loader.js

@@ -0,0 +1,579 @@
+import fs from 'fs';
+import path from 'path';
+import lodash from 'lodash';
+import chokidar from 'chokidar';
+import schedule from 'node-schedule';
+import { listener } from '../listener/listener.js';
+import PluginApp from './app.js';
+import { render } from '../../render/index.js';
+import { common, handler, logger } from '../../utils/index.js';
+class PluginLoader {
+    dir;
+    dirPath;
+    /**
+     * - 插件索引ID
+     */
+    index;
+    /**
+     * - 命令插件索引列表
+     */
+    ruleIds;
+    /**
+     * - 按钮插件索引列表
+     */
+    buttonIds;
+    /**
+     * - accept插件索引列表
+     */
+    acceptIds;
+    /**
+     * - handler
+     */
+    handlerIds;
+    /**
+     * - 插件列表
+     */
+    FileList;
+    /**
+     * - 是否ts环境
+     */
+    isTs;
+    /**
+     * - 是否开发环境
+     */
+    isDev;
+    /**
+     * - 最终缓存的插件列表 通过index索引
+     */
+    PluginList;
+    /**
+     * - 定时任务
+     */
+    task;
+    /**
+     * - 监听器
+     */
+    watcher;
+    /**
+     * - 热更新列表
+     */
+    watchList;
+    /**
+     * - 所有插件包package.json
+     */
+    pkgJson;
+    /**
+     * - 依赖缺失收集
+     */
+    dependErr;
+    constructor() {
+        this.index = 0;
+        this.dir = './plugins';
+        this.dirPath = common.urlToPath(import.meta.url);
+        this.isTs = process.env.karin_app_lang === 'ts';
+        this.isDev = process.env.karin_app_mode === 'dev';
+        this.watcher = new Map();
+        this.watchList = [];
+        this.FileList = [];
+        this.PluginList = {};
+        this.task = [];
+        this.ruleIds = [];
+        this.acceptIds = [];
+        this.buttonIds = [];
+        this.handlerIds = {};
+        this.pkgJson = {};
+        this.dependErr = {};
+    }
+    /**
+     * 插件初始化
+     */
+    async load() {
+        await this.getPlugins();
+        listener.once('plugin.watch', () => {
+            for (const v of this.watchList) {
+                v.name ? this.watch(v.dir, v.name) : this.watchDir(v.dir);
+                logger.debug(`[热更新][${v.dir}]${v.name ? `[${v.name}]` : ''} 监听中...`);
+            }
+        });
+        logger.info(logger.green('-----------'));
+        logger.info('加载插件中..');
+        /** 载入插件 */
+        const promises = this.FileList.map(async ({ dir, name }) => await this.createdApp(dir, name, false));
+        /** 获取npm插件 */
+        const npm = await common.getNpmPlugins(true);
+        /** 载入npm插件 */
+        promises.push(...npm.map(async ({ dir, name, isMain }) => await this.createdApp(dir, name, false, true, isMain)));
+        /** 等待所有插件加载完成 */
+        await Promise.all(promises);
+        /** 打印依赖缺失 */
+        this.printDependErr();
+        /** 释放缓存 */
+        this.FileList = [];
+        /** 优先级排序并打印插件信息 */
+        this.orderBy(true);
+        listener.emit('plugin.watch');
+        return this;
+    }
+    /**
+     * 获取所有插件
+     */
+    async getPlugins() {
+        /** 获取所有插件包 */
+        const plugins = common.getPlugins();
+        for (const dir of plugins) {
+            /**
+             * - 插件包路径
+             * - 例如: ./plugins/karin-plugin-example
+             */
+            const PluginPath = `${this.dir}/${dir}`;
+            /**
+             * 一共3种模式
+             * 1. npm run dev 开发模式  直接加载ts，js文件，对于同时存在编译产物、源代码的情况，优先加载编译产物而不加载源代码
+             * 2. node . 生产模式  只加载js文件
+             * 3. npm run debug 调试模式 利用tsx自身的热更新机制，重启karin
+             */
+            /** 非插件包 加载该文件夹下全部js 视语言环境加载ts */
+            if (!common.isPlugin(PluginPath)) {
+                this.getApps(dir, this.isTs, true);
+                continue;
+            }
+            /** package */
+            const pkg = common.readJson(`${PluginPath}/package.json`);
+            /** 缓存package.json */
+            this.pkgJson[dir] = pkg;
+            /** 入口文件 */
+            if (pkg.main) {
+                const { dir: dirName, pop } = common.splitPath(pkg.main);
+                const dirPath = `${dir}/${dirName}`;
+                if (common.exists(`${this.dir}/${dirPath}/${pop}`)) {
+                    this.FileList.push({ dir: dirPath, name: pop });
+                    this.isDev && this.watchList.push({ dir: dirPath, name: pop });
+                }
+                else {
+                    logger.debug(`[插件收集][${pkg.main}] 入口文件不存在，已忽略`);
+                }
+            }
+            else {
+                /** 没有配置入口默认为index.js */
+                if (common.exists(`${PluginPath}/index.js`)) {
+                    this.FileList.push({ dir, name: 'index.js' });
+                    this.isDev && this.watchList.push({ dir, name: 'index.js' });
+                }
+            }
+            /** 全部apps路径 */
+            const apps = ['apps'];
+            if (pkg?.karin?.apps && Array.isArray(pkg.karin.apps))
+                apps.push(...pkg.karin.apps);
+            /** js环境 或 ts环境、js插件 */
+            if (!this.isTs || !common.exists(`${PluginPath}/tsconfig.json`)) {
+                apps.forEach((apps) => {
+                    /** 路径存在才加载 */
+                    if (common.isDir(`${PluginPath}/${apps}`)) {
+                        this.getApps((`${dir}/${apps}`), false, this.isDev);
+                    }
+                    else {
+                        logger.debug(`[插件收集][${dir}/${apps}] 路径不存在，已忽略`);
+                    }
+                });
+                continue;
+            }
+            /** ts环境 ts插件 */
+            const outDir = pkg?.karin?.outDir || 'lib';
+            const rootDir = pkg?.karin?.rootDir || 'src';
+            /** 编译产物存在 */
+            if (common.exists(`${PluginPath}/${outDir}/apps`)) {
+                this.getApps((`${dir}/${outDir}/apps`), true, this.isDev);
+                continue;
+            }
+            else {
+                /** 入口文件 */
+                if (common.exists(`${PluginPath}/${rootDir}/index.ts`)) {
+                    const dirPath = `${dir}/${rootDir}`;
+                    this.FileList.push({ dir: dirPath, name: 'index.ts' });
+                    this.isDev && this.watchList.push({ dir: dirPath, name: 'index.ts' });
+                    continue;
+                }
+                /** ts源码 */
+                if (common.exists(`${PluginPath}/${rootDir}/apps`)) {
+                    this.getApps((`${dir}/${rootDir}/apps`), true, this.isDev);
+                    continue;
+                }
+            }
+        }
+        return plugins;
+    }
+    /**
+     * 获取指定文件夹下的所有插件
+     * @param dir - 插件包名称
+     * @param isTs - 是否获取ts插件
+     */
+    getApps(dir, isTs, isWatch = false) {
+        isWatch && this.watchList.push({ dir });
+        const ext = isTs ? ['.js', '.ts'] : ['.js'];
+        const list = fs.readdirSync(`${this.dir}/${dir}`, { withFileTypes: true });
+        for (const file of list) {
+            const extname = path.extname(file.name);
+            if (!ext.includes(extname))
+                continue;
+            this.FileList.push({ dir, name: file.name });
+        }
+    }
+    /**
+     * 排序并打印插件信息
+     * @param isPrint - 是否打印
+     */
+    orderBy(isPrint = false) {
+        let taskCount = 0;
+        let handlerCount = 0;
+        const rule = [];
+        const button = [];
+        const accept = [];
+        Object.keys(this.PluginList).forEach(key => {
+            taskCount += this.PluginList[key].task.length;
+            if (this.PluginList[key].rule.length)
+                rule.push({ key, val: this.PluginList[key].priority });
+            if (this.PluginList[key].button.length)
+                button.push({ key, val: this.PluginList[key].priority });
+            if (this.PluginList[key].accept)
+                accept.push({ key, val: this.PluginList[key].priority });
+        });
+        this.ruleIds = lodash.orderBy(rule, ['val'], ['asc']).map((v) => Number(v.key));
+        logger.debug('rule排序完成...');
+        this.buttonIds = lodash.orderBy(button, ['val'], ['asc']).map((v) => Number(v.key));
+        logger.debug('button排序完成...');
+        this.acceptIds = lodash.orderBy(accept, ['val'], ['asc']).map((v) => Number(v.key));
+        if (!isPrint)
+            return;
+        const PluginListKeys = Object.keys(this.PluginList);
+        const handlerKeys = Object.keys(this.handlerIds);
+        handlerKeys.forEach((key) => {
+            handlerCount += this.handlerIds[key].length;
+        });
+        logger.info(`[插件][${PluginListKeys.length}个] 加载完成`);
+        logger.info(`[渲染器][${render.Apps.length}个] 加载完成`);
+        logger.info(`[rule][${this.ruleIds.length}个] 加载完成`);
+        logger.info(`[button][${this.buttonIds.length}个] 加载完成`);
+        logger.info(`[accept][${this.acceptIds.length}个] 加载完成`);
+        logger.info(`[定时任务][${taskCount}个] 加载完成`);
+        logger.info(`[Handler][Key:${handlerKeys.length}个][fnc:${handlerCount}个] 加载完成`);
+        logger.info(logger.green('-----------'));
+        logger.info(`Karin启动完成：耗时 ${logger.green(process.uptime().toFixed(2))} 秒...`);
+    }
+    /**
+     * 新增插件
+     * @param dir - 插件包路径
+     * @param name - 插件名称
+     * @param isOrderBy - 是否为动态导入 默认为静态导入
+     * @param isNpm - 是否为npm包
+     * @param isMain - 是否为主入口文件
+     */
+    async createdApp(dir, name, isOrderBy = false, isNpm = false, isMain = false) {
+        try {
+            const list = [];
+            let path = `${this.dirPath}${isNpm ? 'node_modules' : 'plugins'}/${dir}/${name}`;
+            if (isOrderBy)
+                path = path + `?${Date.now()}`;
+            const tmp = await import(path);
+            /** npm包的入口文件不作为app载入 只加载 */
+            if (isMain)
+                return true;
+            lodash.forEach(tmp, (App) => {
+                const index = this.index;
+                this.index++;
+                if (typeof App === 'object' && App?.file?.type === 'function') {
+                    if (!App?.name) {
+                        logger.error(`[${dir}][${name}] 插件名称错误`);
+                        return false;
+                    }
+                    App.file.dir = dir;
+                    App.file.name = name;
+                    App.rule.forEach((v, index) => {
+                        App.rule[index].log = v.log === false ? (id, log) => logger.bot('debug', id, log) : (id, log) => logger.bot('mark', id, log);
+                    });
+                    /** handler */
+                    App.task = this.addTaskFnc(dir, App);
+                    this.PluginList[index] = App;
+                    handler.add(index + '', App);
+                    if (App.accept)
+                        this.acceptIds.push(index);
+                    return true;
+                }
+                if (typeof App !== 'function' || !App?.prototype?.constructor)
+                    return false;
+                const Class = new App();
+                if (!Class.name) {
+                    logger.error(`[${dir}][${name}] 插件名称错误`);
+                    return false;
+                }
+                logger.debug(`载入插件 [${name}][${Class.name}]`);
+                this.PluginList[index] = PluginApp({
+                    file: { dir, name, type: 'class', fnc: App },
+                    name: Class.name,
+                    event: Class.event,
+                    priority: Class.priority,
+                    accept: false,
+                });
+                /** 异步收集 加载速度 */
+                list.push(this.addRule(dir, name, index, Class));
+                list.push(this.addTask(dir, name, index, Class, App));
+                list.push(this.addAccept(index, Class));
+                list.push(this.addButton(dir, name, index, Class));
+                list.push(this.addInit(Class));
+                return true;
+            });
+            await Promise.all(list);
+            /** 建立对应的规则索引并排序 */
+            if (isOrderBy)
+                this.orderBy();
+            return true;
+        }
+        catch (error) {
+            if (/Cannot find package '(.+?)'/.exec(error)?.[1]) {
+                const key = `${dir}.${name}`;
+                if (this.dependErr[key])
+                    return false;
+                this.dependErr[key] = {
+                    dir,
+                    name,
+                    depend: /Cannot find package '(.+?)'/.exec(error)?.[1] || '',
+                };
+            }
+            else {
+                logger.error(`载入插件错误：${logger.red(`${dir}/${name}`)}`);
+                logger.error(error);
+            }
+            return false;
+        }
+    }
+    /**
+     * 打印依赖缺失
+     */
+    printDependErr() {
+        try {
+            const keys = Object.keys(this.dependErr);
+            if (!keys.length)
+                return;
+            const msg = ['-----依赖缺失----'];
+            keys.forEach(key => {
+                const { dir, name, depend } = this.dependErr[key];
+                msg.push(`[${dir}][${name}] 缺少依赖：${logger.red(depend)}`);
+            });
+            msg.push('-------------------');
+            logger.error(msg.join('\n'));
+        }
+        finally {
+            /** 回收缓存 */
+            this.dependErr = {};
+        }
+    }
+    /**
+     * 新增rule
+     */
+    async addRule(dir, name, index, Class) {
+        lodash.forEach(Class.rule, val => {
+            if (!val.fnc)
+                return logger.error(`[${dir}][${name}] rule.fnc错误：${Class.name}`);
+            this.PluginList[index].rule.push({
+                reg: val.reg instanceof RegExp ? val.reg : new RegExp(val.reg),
+                fnc: val.fnc,
+                event: val.event,
+                permission: val.permission || "all" /* Permission.All */,
+                log: val.log === false ? (id, log) => logger.debug('mark', id, log) : (id, log) => logger.bot('mark', id, log),
+            });
+        });
+    }
+    /**
+     * 新增task fnc模式
+     */
+    addTaskFnc(dir, App) {
+        const task = [];
+        lodash.forEach(App.task, val => {
+            task.push({
+                name: val.name,
+                cron: val.cron,
+                fnc: val.fnc,
+                log: val.log === false ? (log) => logger.debug(log) : (log) => logger.mark(log),
+                schedule: schedule.scheduleJob(val.cron, async () => {
+                    try {
+                        typeof val.log === 'function' && val.log(`[定时任务][${dir}][${val.name}] 开始执行`);
+                        if (typeof val.fnc === 'function')
+                            await val.fnc();
+                        typeof val.log === 'function' && val.log(`[定时任务][${dir}][${val.name}] 执行完毕`);
+                    }
+                    catch (error) {
+                        logger.error(`[定时任务][${dir}][${val.name}] 执行报错`);
+                        logger.error(error);
+                    }
+                }),
+            });
+            return true;
+        });
+        return task;
+    }
+    /**
+     * 新增task
+     */
+    async addTask(dir, name, index, Class, App) {
+        /** 定时任务 */
+        lodash.forEach(Class.task, val => {
+            if (!val.name)
+                return logger.error(`[${dir}][${name}] 定时任务name错误`);
+            if (!val.cron)
+                return logger.error(`[${dir}][${name}] 定时任务cron错误：${Class.name}`);
+            this.PluginList[index].task.push({
+                name: val.name,
+                cron: val.cron,
+                fnc: val.fnc,
+                log: val.log === false ? (log) => logger.debug(log) : (log) => logger.mark(log),
+                schedule: schedule.scheduleJob(val.cron, async () => {
+                    try {
+                        typeof val.log === 'function' && val.log(`[定时任务][${dir}][${val.name}] 开始执行`);
+                        if (typeof val.fnc === 'function') {
+                            await val.fnc();
+                        }
+                        else {
+                            const cla = new App();
+                            await cla[val.fnc]();
+                        }
+                        typeof val.log === 'function' && val.log(`[定时任务][${dir}][${val.name}] 执行完毕`);
+                    }
+                    catch (error) {
+                        logger.error(`[定时任务][${dir}][${val.name}] 执行报错`);
+                        logger.error(error);
+                    }
+                }),
+            });
+        });
+    }
+    /**
+     * 新增accept、handler
+     */
+    async addAccept(index, Class) {
+        if ('accept' in Class && typeof Class.accept === 'function') {
+            this.PluginList[index].accept = true;
+            this.acceptIds.push(index);
+        }
+        await handler.add(index + '', Class);
+    }
+    /**
+     * 新增button
+     */
+    async addButton(dir, name, index, Class) {
+        lodash.forEach(Class.button, val => {
+            if (!val.fnc)
+                return logger.error(`[${dir}][${name}] button.fnc错误：${Class.name}`);
+            this.PluginList[index].button.push({
+                reg: val.reg instanceof RegExp ? val.reg : new RegExp(val.reg),
+                fnc: val.fnc,
+            });
+        });
+    }
+    /**
+     * 执行初始化
+     */
+    async addInit(Class) {
+        'init' in Class && typeof Class.init === 'function' && await Class.init();
+    }
+    /**
+     * 卸载插件
+     */
+    uninstallApp(dir, name) {
+        const index = [];
+        Object.keys(this.PluginList).forEach(key => {
+            const info = this.PluginList[key];
+            /** 停止定时任务 */
+            info.task.forEach(val => val.schedule?.cancel());
+            if (info.file.dir === dir && info.file.name === name) {
+                index.push(key);
+                delete this.PluginList[key];
+            }
+        });
+        /** 删除handler */
+        index.forEach(key => handler.del(key));
+        /** 重新排序 */
+        this.orderBy();
+    }
+    /**
+     * 监听单个文件热更新
+     */
+    watch(dir, name) {
+        if (this.watcher.get(`${dir}.${name}`))
+            return;
+        const file = `./plugins/${dir}/${name}`;
+        const watcher = chokidar.watch(file);
+        /** 监听修改 */
+        watcher.on('change', async () => {
+            /** 卸载 */
+            this.uninstallApp(dir, name);
+            /** 载入插件 */
+            await this.createdApp(dir, name, true);
+            logger.mark(`[修改插件][${dir}][${name}]`);
+        });
+        /** 监听删除 */
+        watcher.on('unlink', async () => {
+            /** 卸载 */
+            this.uninstallApp(dir, name);
+            this.watcher.delete(`${dir}.${name}`);
+            logger.mark(`[卸载插件][${dir}][${name}]`);
+            /** 卸载之后停止监听 */
+            watcher.close();
+        });
+        this.watcher.set(`${dir}.${name}`, watcher);
+    }
+    /**
+     * 监听文件夹更新
+     */
+    async watchDir(dir) {
+        if (this.watcher.get(dir))
+            return;
+        const file = `${this.dir}/${dir}/`;
+        const watcher = chokidar.watch(file);
+        await common.sleep(1000);
+        watcher.on('add', async (_path) => {
+            /** 排除掉不符合规则文件新增 */
+            const ext = this.isTs ? ['.js', '.ts'] : ['.js'];
+            if (!ext.some(ext => _path.endsWith(ext)))
+                return;
+            const name = path.basename(_path);
+            await this.createdApp(dir, name, true);
+            logger.mark(`[新增插件][${dir}][${name}]`);
+            return true;
+        });
+        watcher.on('change', async (_path) => {
+            /** 排除掉不符合规则文件新增 */
+            const ext = this.isTs ? ['.js', '.ts'] : ['.js'];
+            if (!ext.some(ext => _path.endsWith(ext)))
+                return;
+            const name = path.basename(_path);
+            /** 卸载 */
+            this.uninstallApp(dir, name);
+            /** 载入插件 */
+            await this.createdApp(dir, name, true);
+            logger.mark(`[修改插件][${dir}][${name}]`);
+            return true;
+        });
+        watcher.on('unlink', async (_path) => {
+            /** 排除掉不符合规则文件新增 */
+            const ext = this.isTs ? ['.js', '.ts'] : ['.js'];
+            if (!ext.some(ext => _path.endsWith(ext)))
+                return;
+            const name = path.basename(_path);
+            /** 卸载 */
+            this.uninstallApp(dir, name);
+            logger.mark(`[卸载插件][${dir}][${name}]`);
+            return true;
+        });
+        /** 这里需要检查一下是否已经存在，已经存在就关掉之前的监听 */
+        const isExist = this.watcher.get(dir);
+        if (isExist) {
+            isExist.close();
+            this.watcher.delete(dir);
+        }
+        this.watcher.set(dir, watcher);
+        return true;
+    }
+}
+/**
+ * 加载插件
+ */
+export const pluginLoader = new PluginLoader();

package/lib/core/process/process.js

@@ -0,0 +1,100 @@
+import { listener } from '../listener/listener.js';
+import { logger, common, config } from '../../utils/index.js';
+/**
+ * 处理基本事件
+ */
+export default class Process {
+    /**
+     * 进程初始化
+     */
+    static async process() {
+        /**
+         * 监听挂起信号 在终端关闭时触发
+         */
+        process.once('SIGHUP', async (code) => await this.exit(code));
+        /**
+         * 监听中断信号 用户按下 Ctrl + C 时触发
+         */
+        process.once('SIGINT', async (code) => await this.exit(code));
+        /**
+         * 监听终止信号 程序正常退出时触发
+         */
+        process.once('SIGTERM', async (code) => await this.exit(code));
+        /**
+         * 监听退出信号 windows下程序正常退出时触发
+         */
+        process.once('SIGBREAK', async (code) => await this.exit(code));
+        /**
+         * 监听退出信号 与 SIGINT 类似，但会生成核心转储
+         */
+        process.once('SIGQUIT', async (code) => await this.exit(code));
+        /**
+         * 监听退出信号 Node.js进程退出时触发
+         */
+        process.once('exit', async (code) => await this.exit(code));
+        /**
+         * 捕获警告
+         */
+        process.on('warning', warning => listener.emit('warn', warning));
+        /**
+         * 捕获错误
+         */
+        process.on('uncaughtException', error => listener.emit('error', error));
+        /**
+         * 捕获未处理的Promise错误
+         */
+        process.on('unhandledRejection', error => listener.emit('error', error));
+        return this;
+    }
+    /**
+     * 检查后台进程
+     */
+    static async check() {
+        const host = `http://127.0.0.1:${config.Server.http.port}/api`;
+        /**
+         * 使用api来检查后台
+         */
+        const res = await common.axios(host + '/ping', 'get', { timeout: 100 });
+        if (!res)
+            return this;
+        logger.mark(logger.red('检测到后台进程 正在关闭'));
+        /** 发退出信号 */
+        await common.axios(host + '/exit', 'get', { timeout: 10 });
+        for (let i = 0; i < 50; i++) {
+            const res = await common.axios(host + '/ping', 'get', { timeout: 100 });
+            /** 请求成功继续循环 */
+            if (res)
+                continue;
+            /** 请求异常即代表后台进程已关闭 */
+            logger.mark(logger.green('后台进程已关闭'));
+            return this;
+        }
+        /**
+         * 走到这里说明后台关闭失败
+         * 根据配置文件判断是否继续
+         */
+        logger.error(logger.red(`后台进程关闭失败，请检查是否有进程正在占用端口${config.Server.http.port}`));
+        if (!config.Config.multi_progress) {
+            logger.error(logger.red('当前配置不允许多进程运行，程序即将退出'));
+            await this.exit(1);
+        }
+        logger.error(logger.red('当前配置允许多进程运行，程序继续运行'));
+        return this;
+    }
+    /**
+     * 退出Karin
+     * @param code 退出码
+     */
+    static async exit(code = 0) {
+        try {
+            const { redis } = await import('../../db/index.js');
+            if (redis && redis.save)
+                await redis.save();
+            logger.mark(`Karin 已停止运行 运行时间：${common.uptime()} 退出码：${code || '未知'}`);
+        }
+        finally {
+            process.exit();
+        }
+    }
+}
+Process.process();