@hlw-midway/core 1.0.0

package/dist/module/config.js

@@ -0,0 +1,109 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HlwModuleConfig = void 0;
+const core_1 = require("@midwayjs/core");
+const fs = require("fs");
+const core_2 = require("../exception/core");
+const _ = require("lodash");
+const location_1 = require("../util/location");
+/**
+ * 模块配置
+ */
+let HlwModuleConfig = class HlwModuleConfig {
+    async init() {
+        const modules = [];
+        // 模块路径
+        const moduleBasePath = `${location_1.default.getRunPath()}/modules/`;
+        if (!fs.existsSync(moduleBasePath)) {
+            return;
+        }
+        if (!this.allConfig['module']) {
+            this.allConfig['module'] = {};
+        }
+        // 全局中间件
+        const globalMiddlewareArr = [];
+        for (const module of fs.readdirSync(moduleBasePath)) {
+            const modulePath = `${moduleBasePath}/${module}`;
+            const dirStats = fs.statSync(modulePath);
+            if (dirStats.isDirectory()) {
+                const configPath = fs.existsSync(`${modulePath}/config.ts`)
+                    ? `${modulePath}/config.ts`
+                    : `${modulePath}/config.js`;
+                if (fs.existsSync(configPath)) {
+                    const moduleConfig = require(configPath).default({
+                        app: this.app,
+                        env: this.app.getEnv(),
+                    });
+                    modules.push({
+                        order: moduleConfig.order || 0,
+                        module: module,
+                    });
+                    await this.moduleConfig(module, moduleConfig);
+                    // 处理全局中间件
+                    if (!_.isEmpty(moduleConfig.globalMiddlewares)) {
+                        globalMiddlewareArr.push({
+                            order: moduleConfig.order || 0,
+                            data: moduleConfig.globalMiddlewares,
+                        });
+                    }
+                }
+                else {
+                    throw new core_2.HlwCoreException(`模块【${module}】缺少config.ts配置文件`);
+                }
+            }
+        }
+        this.modules = _.orderBy(modules, ['order'], ['desc']).map(e => {
+            return e.module;
+        });
+        await this.globalMiddlewareArr(globalMiddlewareArr);
+    }
+    /**
+     * 模块配置
+     * @param module 模块
+     * @param config 配置
+     */
+    async moduleConfig(module, config) {
+        // 追加配置
+        this.allConfig['module'][module] = config;
+    }
+    /**
+     * 全局中间件
+     * @param middleware 中间件
+     */
+    async globalMiddlewareArr(middlewares) {
+        middlewares = _.orderBy(middlewares, ['order'], ['desc']);
+        for (const middleware of middlewares) {
+            for (const item of middleware.data) {
+                this.app.getMiddleware().insertLast(item);
+            }
+        }
+    }
+};
+exports.HlwModuleConfig = HlwModuleConfig;
+__decorate([
+    (0, core_1.App)(),
+    __metadata("design:type", Object)
+], HlwModuleConfig.prototype, "app", void 0);
+__decorate([
+    (0, core_1.Config)(core_1.ALL),
+    __metadata("design:type", Object)
+], HlwModuleConfig.prototype, "allConfig", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HlwModuleConfig.prototype, "init", null);
+exports.HlwModuleConfig = HlwModuleConfig = __decorate([
+    (0, core_1.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], HlwModuleConfig);

package/dist/module/import.d.ts

@@ -0,0 +1,64 @@
+import { ILogger, IMidwayApplication } from '@midwayjs/core';
+import { TypeORMDataSourceManager } from '@midwayjs/typeorm';
+import { DataSource } from 'typeorm';
+import { HlwEventManager } from '../event';
+import { HlwModuleConfig } from './config';
+import { HlwModuleMenu } from './menu';
+/**
+ * 模块sql
+ */
+export declare class HlwModuleImport {
+    ormConfig: any;
+    defaultDataSource: DataSource;
+    typeORMDataSourceManager: TypeORMDataSourceManager;
+    hlwConfig: any;
+    coreLogger: ILogger;
+    hlwModuleConfig: HlwModuleConfig;
+    hlwEventManager: HlwEventManager;
+    app: IMidwayApplication;
+    hlwModuleMenu: HlwModuleMenu;
+    initJudge: 'file' | 'db';
+    /**
+     * 初始化
+     */
+    init(): Promise<void>;
+    /**
+     * 获取数据库元数据
+     */
+    getDbMetadatas(): Promise<any>;
+    /**
+     * 检查数据是否存在
+     * @param module
+     * @param metadatas
+     */
+    checkDbExist(module: string, metadatas: any): Promise<boolean>;
+    /**
+     * 检查文件是否存在
+     * @param module
+     */
+    checkFileExist(module: string): {
+        exist: boolean;
+        lockPath: string;
+    };
+    /**
+     * 导入数据库
+     * @param module
+     * @param lockPath 锁定导入
+     */
+    initDataBase(module: string, metadatas: any, lockPath?: string): Promise<void>;
+    /**
+     * 锁定导入
+     * @param module
+     * @param metadatas
+     * @param lockPath
+     * @param time
+     */
+    lockImportData(module: string, metadatas: any, lockPath: string, time: number): Promise<void>;
+    /**
+     * 导入数据
+     * @param metadatas
+     * @param datas
+     * @param tableName
+     */
+    importData(metadatas: any[], item: any, tableName: string, parentItem?: any): Promise<void>;
+}

package/dist/module/import.js

@@ -0,0 +1,244 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HlwModuleImport = void 0;
+const core_1 = require("@midwayjs/core");
+const core_2 = require("@midwayjs/core");
+const typeorm_1 = require("@midwayjs/typeorm");
+const fs = require("fs");
+const _ = require("lodash");
+const path = require("path");
+const typeorm_2 = require("typeorm");
+const event_1 = require("../event");
+const config_1 = require("./config");
+const menu_1 = require("./menu");
+const location_1 = require("../util/location");
+/**
+ * 模块sql
+ */
+let HlwModuleImport = class HlwModuleImport {
+    /**
+     * 初始化
+     */
+    async init() {
+        this.initJudge = this.hlwConfig.initJudge;
+        if (!this.initJudge) {
+            this.initJudge = 'file';
+        }
+        // 是否需要导入
+        if (this.hlwConfig.initDB) {
+            const modules = this.hlwModuleConfig.modules;
+            if (!modules || modules.length === 0)
+                return;
+            const metadatas = await this.getDbMetadatas();
+            setTimeout(async () => {
+                for (const module of modules) {
+                    if (this.initJudge == 'file') {
+                        const { exist, lockPath } = this.checkFileExist(module);
+                        if (!exist) {
+                            await this.initDataBase(module, metadatas, lockPath);
+                        }
+                    }
+                    if (this.initJudge == 'db') {
+                        const exist = await this.checkDbExist(module, metadatas);
+                        if (!exist) {
+                            await this.initDataBase(module, metadatas);
+                        }
+                    }
+                }
+                this.hlwEventManager.emit('onDBInit', {});
+                this.hlwModuleMenu.init();
+            }, 2000);
+        }
+    }
+    /**
+     * 获取数据库元数据
+     */
+    async getDbMetadatas() {
+        // 获得所有的实体
+        const entityMetadatas = this.defaultDataSource.entityMetadatas;
+        const metadatas = _.mapValues(_.keyBy(entityMetadatas, 'tableName'), 'target');
+        return metadatas;
+    }
+    /**
+     * 检查数据是否存在
+     * @param module
+     * @param metadatas
+     */
+    async checkDbExist(module, metadatas) {
+        const cKey = `init_db_${module}`;
+        const repository = this.defaultDataSource.getRepository(metadatas['system_config']);
+        const data = await repository.findOneBy({ key: (0, typeorm_2.Equal)(cKey) });
+        return !!data;
+    }
+    /**
+     * 检查文件是否存在
+     * @param module
+     */
+    checkFileExist(module) {
+        const importLockPath = path.join(`${location_1.default.getRunPath()}`, '..', 'lock', 'db');
+        if (!fs.existsSync(importLockPath)) {
+            fs.mkdirSync(importLockPath, { recursive: true });
+        }
+        const lockPath = path.join(importLockPath, module + '.db.lock');
+        return {
+            exist: fs.existsSync(lockPath),
+            lockPath,
+        };
+    }
+    /**
+     * 导入数据库
+     * @param module
+     * @param lockPath 锁定导入
+     */
+    async initDataBase(module, metadatas, lockPath) {
+        // 计算耗时
+        const startTime = new Date().getTime();
+        // 模块路径
+        const modulePath = `${location_1.default.getRunPath()}/modules/${module}`;
+        // 数据路径
+        const dataPath = `${modulePath}/db.json`;
+        // 判断文件是否存在
+        if (fs.existsSync(dataPath)) {
+            // 读取数据
+            const data = JSON.parse(fs.readFileSync(dataPath).toString() || '{}');
+            // 导入数据
+            for (const key in data) {
+                try {
+                    for (const item of data[key]) {
+                        await this.importData(metadatas, item, key);
+                    }
+                }
+                catch (e) {
+                    this.coreLogger.error('\x1B[36m [hlw:core] midwayjs hlw core init ' +
+                        module +
+                        ' database err \x1B[0m');
+                    continue;
+                }
+            }
+            const endTime = new Date().getTime();
+            await this.lockImportData(module, metadatas, lockPath, endTime - startTime);
+            this.coreLogger.info('\x1B[36m [hlw:core] midwayjs hlw core init ' +
+                module +
+                ' database complete \x1B[0m');
+        }
+    }
+    /**
+     * 锁定导入
+     * @param module
+     * @param metadatas
+     * @param lockPath
+     * @param time
+     */
+    async lockImportData(module, metadatas, lockPath, time) {
+        if (this.initJudge == 'file') {
+            fs.writeFileSync(lockPath, `time consuming：${time}ms`);
+        }
+        if (this.initJudge == 'db') {
+            const repository = this.defaultDataSource.getRepository(metadatas['system_config']);
+            if (this.ormConfig.default.type == 'postgres') {
+                await repository.save(repository.create({
+                    key: `init_db_${module}`,
+                    value: `time consuming：${time}ms`,
+                }));
+            }
+            else {
+                await repository.insert({
+                    key: `init_db_${module}`,
+                    value: `time consuming：${time}ms`,
+                });
+            }
+        }
+    }
+    /**
+     * 导入数据
+     * @param metadatas
+     * @param datas
+     * @param tableName
+     */
+    async importData(metadatas, item, tableName, parentItem = null) {
+        const repository = this.defaultDataSource.getRepository(metadatas[tableName]);
+        // 处理当前项中的引用
+        if (parentItem) {
+            for (const key in item) {
+                if (typeof item[key] === 'string' && item[key].startsWith('@')) {
+                    const parentKey = item[key].substring(1); // 移除"@"符号
+                    if (Object.prototype.hasOwnProperty.call(parentItem, parentKey)) {
+                        item[key] = parentItem[parentKey];
+                    }
+                }
+            }
+        }
+        // 插入当前项到数据库
+        let insertedItem;
+        if (this.ormConfig.default.type == 'postgres') {
+            insertedItem = await repository.save(repository.create(item));
+            if (item.id) {
+                await repository.update(insertedItem.id, { id: item.id });
+                await this.defaultDataSource.query(`SELECT setval('${tableName}_id_seq', (SELECT MAX(id) FROM ${tableName}));`);
+            }
+        }
+        else {
+            insertedItem = await repository.insert(item);
+        }
+        // 递归处理@childDatas
+        if (!_.isEmpty(item['@childDatas'])) {
+            const childDatas = item['@childDatas'];
+            delete item['@childDatas'];
+            for (const childKey in childDatas) {
+                for (const childItem of childDatas[childKey]) {
+                    await this.importData(metadatas, childItem, childKey, item);
+                }
+            }
+        }
+    }
+};
+exports.HlwModuleImport = HlwModuleImport;
+__decorate([
+    (0, core_2.Config)('typeorm.dataSource'),
+    __metadata("design:type", Object)
+], HlwModuleImport.prototype, "ormConfig", void 0);
+__decorate([
+    (0, typeorm_1.InjectDataSource)('default'),
+    __metadata("design:type", typeorm_2.DataSource)
+], HlwModuleImport.prototype, "defaultDataSource", void 0);
+__decorate([
+    (0, core_2.Inject)(),
+    __metadata("design:type", typeorm_1.TypeORMDataSourceManager)
+], HlwModuleImport.prototype, "typeORMDataSourceManager", void 0);
+__decorate([
+    (0, core_2.Config)('hlw'),
+    __metadata("design:type", Object)
+], HlwModuleImport.prototype, "hlwConfig", void 0);
+__decorate([
+    (0, core_2.Logger)(),
+    __metadata("design:type", Object)
+], HlwModuleImport.prototype, "coreLogger", void 0);
+__decorate([
+    (0, core_2.Inject)(),
+    __metadata("design:type", config_1.HlwModuleConfig)
+], HlwModuleImport.prototype, "hlwModuleConfig", void 0);
+__decorate([
+    (0, core_2.Inject)(),
+    __metadata("design:type", event_1.HlwEventManager)
+], HlwModuleImport.prototype, "hlwEventManager", void 0);
+__decorate([
+    (0, core_2.App)(),
+    __metadata("design:type", Object)
+], HlwModuleImport.prototype, "app", void 0);
+__decorate([
+    (0, core_2.Inject)(),
+    __metadata("design:type", menu_1.HlwModuleMenu)
+], HlwModuleImport.prototype, "hlwModuleMenu", void 0);
+exports.HlwModuleImport = HlwModuleImport = __decorate([
+    (0, core_2.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], HlwModuleImport);

package/dist/module/menu.d.ts

@@ -0,0 +1,54 @@
+import { ILogger, IMidwayApplication } from '@midwayjs/core';
+import { TypeORMDataSourceManager } from '@midwayjs/typeorm';
+import { DataSource } from 'typeorm';
+import { HlwEventManager } from '../event';
+import { HlwConfig } from '../interface';
+import { HlwModuleConfig } from './config';
+/**
+ * 菜单
+ */
+export declare class HlwModuleMenu {
+    hlwModuleConfig: HlwModuleConfig;
+    hlwConfig: HlwConfig;
+    app: IMidwayApplication;
+    coreLogger: ILogger;
+    hlwEventManager: HlwEventManager;
+    initJudge: 'file' | 'db';
+    ormConfig: any;
+    defaultDataSource: DataSource;
+    typeORMDataSourceManager: TypeORMDataSourceManager;
+    datas: {};
+    init(): Promise<void>;
+    /**
+     * 导入菜单
+     * @param module
+     * @param lockPath
+     */
+    importMenu(module: string, metadatas: any, lockPath?: string): Promise<void>;
+    /**
+     * 获取数据库元数据
+     */
+    getDbMetadatas(): Promise<any>;
+    /**
+     * 检查数据是否存在
+     * @param module
+     * @param metadatas
+     */
+    checkDbExist(module: string, metadatas: any): Promise<boolean>;
+    /**
+     * 检查文件是否存在
+     * @param module
+     */
+    checkFileExist(module: string): {
+        exist: boolean;
+        lockPath: string;
+    };
+    /**
+     * 锁定导入
+     * @param module
+     * @param metadatas
+     * @param lockPath
+     * @param time
+     */
+    lockImportData(module: string, metadatas: any, lockPath: string): Promise<void>;
+}

package/dist/module/menu.js

@@ -0,0 +1,178 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HlwModuleMenu = void 0;
+const core_1 = require("@midwayjs/core");
+const typeorm_1 = require("@midwayjs/typeorm");
+const fs = require("fs");
+const _ = require("lodash");
+const path = require("path");
+const typeorm_2 = require("typeorm");
+const event_1 = require("../event");
+const config_1 = require("./config");
+const location_1 = require("../util/location");
+/**
+ * 菜单
+ */
+let HlwModuleMenu = class HlwModuleMenu {
+    constructor() {
+        this.datas = {};
+    }
+    async init() {
+        this.initJudge = this.hlwConfig.initJudge;
+        if (!this.initJudge) {
+            this.initJudge = 'file';
+        }
+        // 是否需要导入
+        if (this.hlwConfig.initMenu) {
+            const modules = this.hlwModuleConfig.modules;
+            const metadatas = await this.getDbMetadatas();
+            for (const module of modules) {
+                if (this.initJudge == 'file') {
+                    const { exist, lockPath } = this.checkFileExist(module);
+                    if (!exist) {
+                        await this.importMenu(module, metadatas, lockPath);
+                    }
+                }
+                if (this.initJudge == 'db') {
+                    const exist = await this.checkDbExist(module, metadatas);
+                    if (!exist) {
+                        await this.importMenu(module, metadatas);
+                    }
+                }
+            }
+            this.hlwEventManager.emit('onMenuImport', this.datas);
+        }
+    }
+    /**
+     * 导入菜单
+     * @param module
+     * @param lockPath
+     */
+    async importMenu(module, metadatas, lockPath) {
+        // 模块路径
+        const modulePath = `${location_1.default.getRunPath()}/modules/${module}`;
+        // json 路径
+        const menuPath = `${modulePath}/menu.json`;
+        // 导入
+        if (fs.existsSync(menuPath)) {
+            const data = fs.readFileSync(menuPath);
+            try {
+                // this.hlwEventManager.emit("onMenuImport", module, JSON.parse(data.toString()));
+                this.datas[module] = JSON.parse(data.toString());
+                await this.lockImportData(module, metadatas, lockPath);
+            }
+            catch (error) {
+                this.coreLogger.error(error);
+                this.coreLogger.error(`自动初始化模块[${module}]菜单失败，请检查对应的数据结构是否正确`);
+            }
+        }
+    }
+    /**
+     * 获取数据库元数据
+     */
+    async getDbMetadatas() {
+        // 获得所有的实体
+        const entityMetadatas = this.defaultDataSource.entityMetadatas;
+        const metadatas = _.mapValues(_.keyBy(entityMetadatas, 'tableName'), 'target');
+        return metadatas;
+    }
+    /**
+     * 检查数据是否存在
+     * @param module
+     * @param metadatas
+     */
+    async checkDbExist(module, metadatas) {
+        const cKey = `init_menu_${module}`;
+        const repository = this.defaultDataSource.getRepository(metadatas['system_config']);
+        const data = await repository.findOneBy({ key: (0, typeorm_2.Equal)(cKey) });
+        return !!data;
+    }
+    /**
+     * 检查文件是否存在
+     * @param module
+     */
+    checkFileExist(module) {
+        const importLockPath = path.join(`${location_1.default.getRunPath()}`, '..', 'lock', 'menu');
+        if (!fs.existsSync(importLockPath)) {
+            fs.mkdirSync(importLockPath, { recursive: true });
+        }
+        const lockPath = path.join(importLockPath, module + '.menu.lock');
+        return {
+            exist: fs.existsSync(lockPath),
+            lockPath,
+        };
+    }
+    /**
+     * 锁定导入
+     * @param module
+     * @param metadatas
+     * @param lockPath
+     * @param time
+     */
+    async lockImportData(module, metadatas, lockPath) {
+        if (this.initJudge == 'file') {
+            fs.writeFileSync(lockPath, 'success');
+        }
+        if (this.initJudge == 'db') {
+            const repository = this.defaultDataSource.getRepository(metadatas['system_config']);
+            if (this.ormConfig.default.type == 'postgres') {
+                await repository.save(repository.create({
+                    key: `init_menu_${module}`,
+                    value: 'success',
+                }));
+            }
+            else {
+                await repository.insert({
+                    key: `init_menu_${module}`,
+                    value: 'success',
+                });
+            }
+        }
+    }
+};
+exports.HlwModuleMenu = HlwModuleMenu;
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", config_1.HlwModuleConfig)
+], HlwModuleMenu.prototype, "hlwModuleConfig", void 0);
+__decorate([
+    (0, core_1.Config)('hlw'),
+    __metadata("design:type", Object)
+], HlwModuleMenu.prototype, "hlwConfig", void 0);
+__decorate([
+    (0, core_1.App)(),
+    __metadata("design:type", Object)
+], HlwModuleMenu.prototype, "app", void 0);
+__decorate([
+    (0, core_1.Logger)(),
+    __metadata("design:type", Object)
+], HlwModuleMenu.prototype, "coreLogger", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", event_1.HlwEventManager)
+], HlwModuleMenu.prototype, "hlwEventManager", void 0);
+__decorate([
+    (0, core_1.Config)('typeorm.dataSource'),
+    __metadata("design:type", Object)
+], HlwModuleMenu.prototype, "ormConfig", void 0);
+__decorate([
+    (0, typeorm_1.InjectDataSource)('default'),
+    __metadata("design:type", typeorm_2.DataSource)
+], HlwModuleMenu.prototype, "defaultDataSource", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", typeorm_1.TypeORMDataSourceManager)
+], HlwModuleMenu.prototype, "typeORMDataSourceManager", void 0);
+exports.HlwModuleMenu = HlwModuleMenu = __decorate([
+    (0, core_1.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], HlwModuleMenu);