@lixianwei/elpis 1.0.0

package/elpis-core/loader/service.js

@@ -0,0 +1,64 @@
+const glob =  require('glob');
+const path = require('path');
+const {sep} = path
+/*
+* service loader
+* @param{object} app Koa 实例
+* 加载所有service，可通过 'app.service.${目录}.${文件}' 访问
+* 例子
+* app/service
+*  |
+*  | --custom-module
+*        |
+*        | --custom-service.js
+*   => app.service.customModule.customService
+* */
+
+module.exports = (app) => {
+
+    const service = {}
+    // 读取elpis/app/service/**/**.js 下所有文件
+    const elpisServicePath = path.resolve(__dirname,`..${sep}..${sep}app${sep}service`);
+    const elpisFileList = glob.sync(path.resolve(elpisServicePath,  `.${sep}**${sep}**.js`));
+    elpisFileList.forEach(file => {
+        handelFile(file)
+    })
+
+    // 读取业务/app/service/**/**.js 下所有文件
+    const businessServicePath = path.resolve(app.businessPath,`.${sep}service`);
+    const businessFileList = glob.sync(path.resolve(businessServicePath,  `.${sep}**${sep}**.js`));
+    businessFileList.forEach(file => {
+        handelFile(file)
+    })
+    //把内容加载到app.service 下
+
+    function handelFile(file){
+        //提取文件名称
+        let name = path.resolve(file)
+
+        // 截取路径 app/service/custom-module/custom-service.js =>custom-module/custom-service
+        name = name.substring(name.lastIndexOf(`service${sep}`)+`service${sep}`.length,name.lastIndexOf('.'));
+
+        //把'-' 统一改成驼峰命名
+        name = name.replace(/[_-][a-z]/ig,(s)=>s.substring(1).toUpperCase());
+
+        //挂载sevice到内存app对象中
+        let temService = service;
+        const names = name.split(sep) //[customModule(目录),customService(文件)]
+        for(let i =0,len = names.length;i<len; ++i ){
+            if(i===len - 1){
+                const ServiceMoule = require(path.resolve(file))(app)
+                temService[names[i]] = new ServiceMoule();
+            }else{
+                if(!temService[names[i]]){
+                    temService[names[i]] = {};
+                }
+                temService = temService[names[i]];
+            }
+        }
+    }
+
+    // console.log(service,'service')
+    app.service = service;
+};
+

package/index.js

@@ -0,0 +1,41 @@
+const ElpisCore = require('./elpis-core');
+// 引入 前端工程化构建方法
+const FEBuildDev = require('./app/webpack/dev.js');
+const FEBuildProd = require('./app/webpack/prod.js');
+
+module.exports = {
+
+    /*
+    * 服务端基础
+    * */
+    Controller:{
+        Base:require('./app/controller/base.js'),
+    },
+    Service:{
+      Base:require('./app/service/base.js'),
+    },
+
+    /*
+    *  编译构建前端工程
+    * @params env 环境变量 local/production
+    * */
+    frontendBuild(env){
+        if(env === 'local'){
+            FEBuildDev()
+        }else if(env === 'production'){
+            FEBuildProd()
+        }
+    },
+    /*
+    * 启动elpis
+    * @params options 项目配置  透传到elpis-core
+    * */
+    serverStart(options = {}) {
+        // 启动项目
+       const app =  ElpisCore.start(options)
+        return app
+    }
+};
+
+
+

package/model/index.js

@@ -0,0 +1,105 @@
+const _ = require('lodash')
+const glob = require('glob');
+const path = require('path');
+const {sep} = path;
+
+ // project 继承model方法
+const projectExtendModel =(model,project)=>{
+    return _.mergeWith({}, model,project,(modelValue,projValue) => {
+        // 处理数组合并的情况
+        if(Array.isArray(modelValue)&&Array.isArray(projValue)){
+            let result = [];
+            // 因为project继承model 所以需要处理修改和新增内容情况
+            // project 有的键值，model也有  => 修改（重载）
+            // project 有的键值，model 没有 => 新增 (拓展)
+            // model有的键值，project没有 => 保留（继承）
+
+            // 处理修改和保留
+            for(let i = 0; i < modelValue.length; ++i){
+                let modelItem = modelValue[i];
+                const projItem = projValue.find(projItem=>projItem.key === modelItem.key);
+                // project有的键值，model也有 则递归调用，projectExtendModel 方法覆盖
+                result.push(projItem?projectExtendModel(modelItem,projItem):modelItem);
+            }
+            // 处理新增
+            for (let i= 0; i<projValue.length; ++i){
+                const projItem = projValue[i];
+                const modelItem = modelValue.find(modelItem=>modelItem.key === projItem.key);
+                if(!modelItem){
+                    result.push(projItem);
+                }
+            }
+            return result;
+        }
+
+    });
+}
+/*
+* 解析model配置，并返回组织且继承后的数据结构
+* [{
+*   model:${model}
+*   project:{
+*       proj1:${proj1},
+*       proj2:${proj2}
+*   }
+* },...]
+* */
+
+module.exports=(app)=>{
+    const modelList = [];
+    // 遍历当前文件夹，构造模型数据结构，挂载到modelList上
+    const modelPath = path.resolve(app.baseDir,`.${sep}/model`)
+    const fileList = glob.sync(path.resolve(modelPath,`.${sep}**${sep}**.js`));
+    fileList.forEach(file=>{
+        if(file.indexOf('index.js')>-1) {
+            return;
+        }
+
+        // 区分配置类型（model/project）
+        // windows系统需要在这个地方转换一下 不然windows系统识别sep 为 \
+        const normalized = path.resolve(file);
+        const type = normalized.indexOf(`${sep}project${sep}`) > -1 ? 'project' : 'model';
+
+        if(type === 'project'){
+            // 正则匹配找到  model/buiness/project/**.js 中的buiness 这个文件标识
+            const modelKey = file.match(/\/model\/(.*?)\/project/)?.[1]
+            // 正则匹配找到  model/buiness/project/**.js 中的project 这个文件标识
+            const projectKey = file.match(/\/project\/(.*?)\.js/)?.[1]
+            let modelItem = modelList.find(item=>item.model?.key === modelKey);
+            if(!modelItem){ //初始话model数据结构
+                modelItem={}
+                modelList.push(modelItem);
+            }
+            if(!modelItem.project){ //初始化project 数据结构
+                modelItem.project={}
+            }
+            modelItem.project[projectKey]= require(path.resolve(file))
+            modelItem.project[projectKey].key = projectKey; //注入projectKey
+            modelItem.project[projectKey].modelKey = modelKey; //注入modelKey
+        }
+
+        if(type === 'model'){
+            // 正则匹配找到  model/buiness/model.js 中的buiness 这个文件标识
+            const modelKey = file.match(/\/model\/(.*?)\/model\.js/)?.[1]
+            let modelItem = modelList.find(item=>item.model?.key === modelKey)
+            if(!modelItem){
+                modelItem = {}
+                modelList.push(modelItem)
+            }
+            modelItem.model = require(path.resolve(file))
+            modelItem.model.key = modelKey //注入modelKey
+
+        }
+
+    })
+
+    // 数据进一步整理 project=>继承model
+    modelList.forEach(item=>{
+        const {model,project} = item;
+        for(const key in project){
+            project[key] = projectExtendModel(model,project[key]);
+        }
+
+    })
+    return modelList
+}

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@lixianwei/elpis",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "cross-env _ENV=local mocha test/**/*.js",
+    "lint": "eslint --quiet --ext js,vue ."
+
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://git.code.tencent.com/li1995/elpis.git"
+  },
+  "author": "lixianwei",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/runtime": "^7.24.0",
+    "@element-plus/icons-vue": "^2.3.2",
+    "ajv": "^6.10.2",
+    "axios": "^0.19.2",
+    "echarts": "^5.5.0",
+    "element-plus": "^2.3.7",
+    "generate-password": "^1.7.1",
+    "glob": "^7.1.4",
+    "jsonwebtoken": "^9.0.2",
+    "knex": "^0.19.0",
+    "koa": "2.7.0",
+    "koa-bodyparser": "^4.2.1",
+    "koa-nunjucks-2": "^3.0.2",
+    "koa-router": "^7.4.0",
+    "koa-static": "^5.0.0",
+    "koa-useragent": "2.0.0",
+    "koa2-cors": "^2.0.6",
+    "less": "^3.8.1",
+    "lodash": "^4.17.21",
+    "log4js": "^6.9.1",
+    "md5": "^2.2.1",
+    "moment": "^2.29.4",
+    "mysql": "^2.18.1",
+    "node-schedule": "^2.1.1",
+    "nodemon": "^1.19.2",
+    "path": "^0.12.7",
+    "pinia": "^2.1.6",
+    "superagent": "^8.1.2",
+    "vue": "^3.3.4",
+    "vue-json-viewer": "^3.0.4",
+    "vue-router": "^4.2.4",
+    "vuex": "^4.1.0",
+    "@babel/plugin-transform-runtime": "^7.1.0",
+    "@babel/preset-env": "^7.4.5",
+    "babel-loader": "^8.0.4",
+    "clean-webpack-plugin": "^0.1.19",
+    "consoler": "^0.2.0",
+    "cross-env": "^10.1.0",
+    "css-loader": "^0.23.1",
+    "css-minimizer-webpack-plugin": "^5.0.1",
+    "directory-named-webpack-plugin": "^4.0.1",
+    "express": "^4.18.2",
+    "file-loader": "^6.2.0",
+    "happypack": "^5.0.1",
+    "html-webpack-inject-attributes-plugin": "^1.0.1",
+    "html-webpack-plugin": "^5.5.3",
+    "less-loader": "^11.1.3",
+    "mini-css-extract-plugin": "^2.7.6",
+    "style-loader": "^0.14.1",
+    "terser-webpack-plugin": "^5.6.1",
+    "url-loader": "^4.1.1",
+    "vue-loader": "^17.2.2",
+    "vue-style-loader": "^4.1.2",
+    "webpack": "^5.88.1",
+    "webpack-dev-middleware": "^6.1.1",
+    "webpack-hot-middleware": "^2.25.4",
+    "webpack-merge": "^4.2.1"
+  },
+  "devDependencies": {
+    "assert": "^2.0.0",
+    "babel-eslint": "^10.0.2",
+    "eslint": "^7.32.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-vue": "^9.17.0",
+    "ghooks": "~1.0.3",
+    "mocha": "^6.1.4",
+    "supertest": "^4.0.2",
+    "validate-commit-msg": "~2.14.0"
+  },
+  "config": {
+    "ghooks": {
+      "commit-msg": "validate-commit-msg",
+      "pre-commit": "npm run lint"
+    }
+  }
+}

package/test/controller/project.test.js

@@ -0,0 +1,194 @@
+const assert = require('assert')
+const supertest = require('supertest')
+const md5 = require('md5')
+const eplisCore = require('../../elpis-core')
+
+const signKey = 'klx05hb3n1c9ujp8uhxbs2ikkiowp212';
+
+const st = Date.now();
+describe('测试project 相关接口',function(){
+    this.timeout(60000);
+    let request;
+    let modelList ;
+    const projectList =[];
+    it('启动服务',async ()=>{
+        const app = await eplisCore.start();
+        modelList = require('../../model/index')(app)
+        modelList.forEach(async (modelItem)=>{
+            const  {project} = modelItem
+            for(const pKey in project){
+                projectList.push(project[pKey])
+            }
+        })
+        request = supertest(app.listen());
+    })
+
+
+    it('GET /api/project without proj_key', async ()=>{
+        let tmpRequest = request.get('/api/project');
+        tmpRequest = tmpRequest.set('s_t',st)
+        tmpRequest = tmpRequest.set('s_sign',md5(`${signKey}_${st}`));
+        const res = await tmpRequest
+        assert(res.body.success === false)
+        const resBody = res.body;
+        assert(resBody.code === 442)
+        assert(resBody.message.indexOf(`request validate fail: data should have required property 'proj_key'`) > -1)
+    })
+
+    it('GET /api/project fail', async ()=>{
+        let tmpRequest = request.get('/api/project');
+        tmpRequest = tmpRequest.set('s_t',st)
+        tmpRequest = tmpRequest.set('s_sign',md5(`${signKey}_${st}`));
+        tmpRequest =  tmpRequest.query({
+            proj_key:'xxxxxxxxxx'
+        });
+        const res = await tmpRequest;
+        assert(res.body.success === false)
+        const resBody = res.body;
+        assert(resBody.code === 50000)
+        assert(resBody.message === '获取项目异常')
+
+    })
+
+    it('GET /api/project with proj_key', async ()=>{
+        for(let i =0;i<projectList.length;i++){
+            const {key:projKey} = projectList[i];
+            let tmpRequest = request.get('/api/project');
+            tmpRequest = tmpRequest.set('s_t',st)
+            tmpRequest = tmpRequest.set('s_sign',md5(`${signKey}_${st}`));
+            tmpRequest =  tmpRequest.query({
+                proj_key:projKey
+            });
+            const res = await tmpRequest;
+            assert(res.body.success === true)
+            const resData = res.body.data;
+            assert(resData.key === projKey)
+            assert(resData.name)
+            assert(resData.modelKey)
+            assert(resData.desc !== undefined)
+            assert(resData.homePage !== undefined)
+            const {menu} = resData;
+            menu.forEach(async (menuItem)=>{
+                checkMenuItem(menuItem)
+            })
+        }
+        // 校验menu菜单
+        function checkMenuItem(menuItem){
+            console.log('-----',menuItem.key)
+            assert(menuItem.key)
+            assert(menuItem.name)
+            assert(menuItem.menuType)
+            if(menuItem.menuType === 'group'){
+                assert(menuItem.subMenu !== undefined);
+                menuItem.subMenu.forEach(async (subMenuItem)=>{
+                    checkMenuItem(subMenuItem)
+                })
+
+
+            }
+            if(menuItem.menuType === 'module'){
+                checkModule(menuItem)
+            }
+        }
+        // 检查module 菜单配置
+        function checkModule(menuItem){
+            const {moduleType} = menuItem
+            assert(moduleType)
+            if(moduleType === 'sider'){
+                const {siderConfig} =  menuItem
+                assert(siderConfig)
+                assert(siderConfig.menu)
+                siderConfig.menu.forEach(async (siderMenuItem)=>{
+                    checkMenuItem(siderMenuItem)
+
+                })
+            }
+            if(moduleType === 'iframe'){
+                const {iframeConfig} = menuItem
+                assert(iframeConfig)
+                assert(iframeConfig.path)
+            }
+            if(moduleType === 'custom'){
+                const {customConfig} = menuItem
+                assert(customConfig)
+                assert(customConfig.path)
+            }
+            if(moduleType === 'schema'){
+                const {schemaConfig} = menuItem
+                assert(schemaConfig)
+                assert(schemaConfig.api !== undefined)
+                assert(schemaConfig.schema)
+            }
+        }
+
+    })
+
+
+
+
+    it('GET /api/project/list without proj_key',async ()=>{
+        let tmpRequest = request.get('/api/project/list');
+        tmpRequest = tmpRequest.set('s_t',st)
+        tmpRequest = tmpRequest.set('s_sign',md5(`${signKey}_${st}`));
+        const res = await tmpRequest;
+        assert(res.body.success === true);
+        const resData = res.body.data;
+        assert(resData.length === projectList.length);
+        for(let i=0; i<resData.length; ++i) {
+            const  item = resData[i];
+            assert(item.modelKey)
+            assert(item.key)
+            assert(item.name)
+            assert(item.desc !== undefined)
+            assert(item.homePage !== undefined)
+        }
+    })
+
+    it('GET /api/project/list with proj_key',async ()=>{
+        const {key:projKey} = projectList[Math.floor(Math.random()*projectList.length)];
+        const {modelKey} = await projectList.find(item => item.key === projKey);
+        let tmpRequest = request.get('/api/project/list');
+        tmpRequest = tmpRequest.set('s_t',st)
+        tmpRequest = tmpRequest.set('s_sign',md5(`${signKey}_${st}`));
+        tmpRequest = tmpRequest.query({
+            proj_key: projKey,
+        })
+        const res = await tmpRequest;
+        assert(res.body.success === true);
+        const resData = res.body.data;
+        assert(projectList.filter(item=>item.modelKey===modelKey).length === resData.length);
+        for(let i=0; i<resData.length; ++i) {
+            const  item = resData[i];
+            assert(item.modelKey)
+            assert(item.key)
+            assert(item.name)
+            assert(item.desc !== undefined)
+            assert(item.homePage !== undefined)
+        }
+
+    })
+
+    it('GET /api/project/model_list', async ()=>{
+        let tmpRequest = request.get('/api/project/model_list');
+        tmpRequest = tmpRequest.set('s_t',st)
+        tmpRequest = tmpRequest.set('s_sign',md5(`${signKey}_${st}`));
+        const res = await  tmpRequest;
+
+        assert(res.body.success===true)
+        const resData = res.body.data;
+        assert(resData.length>0)
+        for(let i = 0;i<resData.length;++i){
+            const item = resData[i];
+            assert(item.model)
+            assert(item.model.key)
+            assert(item.model.name)
+            assert(item.project)
+            for(const projKey in item.project){
+                assert(item.project[projKey])
+                assert(item.project[projKey].name)
+                assert(item.project[projKey].key)
+            }
+        }
+    })
+
+})