@mangjuxiong/elpis 1.0.2

package/index.js

@@ -0,0 +1,39 @@
+// 引入 elpis-core
+const ElpisCore = require('./elpis-core');
+// 引入前端工程化构建
+const FEBuildDev = require('./app/webpack/libs/dev.js');
+const FEBuildProd = require('./app/webpack/libs/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
+   * @param options 项目配置，透传到 elpis-core
+   * @returns
+   */
+  serverStart: (options = {}) => {
+    const app = ElpisCore.start(options);
+    return app;
+  },
+};

package/model/index.js

@@ -0,0 +1,107 @@
+const glob = require('glob');
+const path = require('path');
+const { sep } = path;
+const _ = require('lodash');
+
+// 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:{
+ *      projKey1: ${project1},
+ *      projKey2: ${project2},
+ *  }
+ * },...]
+ * 
+ */
+module.exports = (app)=>{
+    const modelList = [];
+
+    // 遍历当前文件夹，构造模型数据结构，挂载到modelList上
+    const modelPath = path.resolve(process.cwd(), `.${sep}model`);
+    const fileLst = glob.sync(path.resolve(modelPath, `.${sep}**${sep}**.js`));
+    fileLst.forEach((file)=>{
+        // 排除掉index.js文件
+        if(file.indexOf('index.js')>-1) return;
+
+        // 区分配置类型 （model / project）
+        const type = file.indexOf(`/project/`) > -1 ? 'project' : 'model';
+        if(type === 'model'){
+            const modelKey = file.match(/\/model\/(.*?)\/model\.js/)?.[1];
+            let modelItem = modelList.find (item=>item.model?.key === modelKey);
+            
+            if(!modelItem){
+                // 初始化model数据结构
+                modelItem = {};
+                modelList.push(modelItem);
+            }
+            modelItem.model = require(path.resolve(file));
+            // 注入model key
+            modelItem.model.key = modelKey;
+        }
+
+        if(type === 'project'){
+            const modelKey = file.match(/\/model\/(.*?)\/project/)?.[1];
+            const projKey = 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[projKey] = require(path.resolve(file));
+            // 注入project key
+            modelItem.project[projKey].key = projKey;
+            // 注入model key
+            modelItem.project[projKey].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,90 @@
+{
+  "name": "@mangjuxiong/elpis",
+  "version": "1.0.2",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "lint": "eslint --quiet --ext js,vue .",
+    "test": "set _ENV='local'&& mocha test/**/*.js"
+  },
+  "author": "mangjuxiong",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/runtime": "^7.27.6",
+    "@element-plus/icons-vue": "^2.3.1",
+    "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",
+    "css-loader": "^0.23.1",
+    "css-minimizer-webpack-plugin": "^5.0.1",
+    "directory-named-webpack-plugin": "^4.0.1",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "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.6.3",
+    "less-loader": "^11.1.3",
+    "mini-css-extract-plugin": "^2.7.6",
+    "style-loader": "^0.14.1",
+    "terser-webpack-plugin": "^5.3.12",
+    "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.1.0",
+    "@babel/eslint-parser": "^7.26.5",
+    "eslint": "^8.57.1",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-vue": "^9.32.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 = 'mshsiksjksnnmsma';
+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.js')(app);
+    modelList.forEach((modelItem) => {
+      const { project } = modelItem;
+      for (const pKey in project) {
+        projectList.push(project[pKey]);
+      }
+    });
+    request = supertest(app.listen());
+  });
+
+  // 获取当前projKey 对应模型下的项目列表,无projKey则返回所有项目
+  it('GET /api/project/list without proj_key', async () => {
+    let tmpRequest = request.get('/api/project/list');
+    tmpRequest = tmpRequest.set('s_sign', md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set('s_t', 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);
+    }
+  });
+  // 获取当前projKey 对应模型下的项目列表
+  it('GET /api/project/list with proj_key', async () => {
+    const project = projectList[Math.floor(Math.random() * projectList.length)];
+    const { modelKey } = projectList.find((item) => item.key === project.key);
+
+    let tmpRequest = request.get('/api/project/list');
+    tmpRequest = tmpRequest.set('s_sign', md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set('s_t', st);
+    tmpRequest = tmpRequest.query({
+      proj_key: project.key,
+    });
+    const res = await tmpRequest;
+    assert(res.body.success === true);
+
+    const resData = res.body.data;
+    assert(resData.length === projectList.filter((item) => item.modelKey === modelKey).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_sign', md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set('s_t', 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) {
+        const proj = item.project[projKey];
+        assert(proj.key);
+        assert(proj.name);
+      }
+    }
+  });
+
+  // 根据proj_key获取项目配置，没有传proj_key则报错
+  it('GET /api/project without proj_key', async () => {
+    let tmpRequest = request.get('/api/project');
+    tmpRequest = tmpRequest.set('s_sign', md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set('s_t', st);
+    const res = await tmpRequest;
+    assert(res.body.success === false);
+
+    const resData = res.body;
+    assert(resData.code === 442);
+    assert(resData.message.indexOf("request validate fail: data should have required property 'proj_key'") > -1);
+  });
+  // 获取当前projKey 对应模型下的项目列表,无projKey则返回所有项目
+  it('GET /api/project fail', async () => {
+    let tmpRequest = request.get('/api/project');
+    tmpRequest = tmpRequest.set('s_sign', md5(`${signKey}_${st}`));
+    tmpRequest = tmpRequest.set('s_t', st);
+    tmpRequest = tmpRequest.query({
+      proj_key: 'xxxxxxxx',
+    });
+    const res = await tmpRequest;
+    assert(res.body.success === false);
+
+    const resData = res.body;
+    assert(resData.code === 50000);
+    assert(resData.message === '项目不存在');
+  });
+  // 获取当前projKey 对应模型下的项目列表,无projKey则返回所有项目
+  it('GET /api/project with proj_key', async () => {
+    for (let i = 0; i < projectList.length; i++) {
+      const project = projectList[i];
+      console.log('----- GET /api/project with proj_key:', project.key);
+      let tmpRequest = request.get('/api/project');
+      tmpRequest = tmpRequest.set('s_sign', md5(`${signKey}_${st}`));
+      tmpRequest = tmpRequest.set('s_t', st);
+      tmpRequest = tmpRequest.query({
+        proj_key: project.key,
+      });
+      const res = await tmpRequest;
+      assert(res.body.success === true);
+
+      const resData = res.body.data;
+      assert(resData.key === project.key);
+      assert(resData.modelKey);
+      assert(resData.name);
+      assert(resData.desc !== undefined);
+      assert(resData.homePage !== undefined);
+
+      const { menu } = resData;
+      menu.forEach((menuItem) => {
+        checkMenuItem(menuItem);
+      });
+    }
+
+    // 校验menu菜单
+    function checkMenuItem(menuItem) {
+      console.log('----- GET /api/project with proj_key checkMenuItem ~ menuItem:', menuItem.key);
+      assert(menuItem.key);
+      assert(menuItem.name);
+      assert(menuItem.menuType);
+
+      if (menuItem.menuType === 'module') {
+        checkMoudle(menuItem);
+      }
+      if (menuItem.menuType === 'group') {
+        assert(menuItem.subMenu !== undefined);
+        menuItem.subMenu.forEach((subMenuItem) => {
+          checkMenuItem(subMenuItem);
+        });
+      }
+    }
+
+    // 检查moudle菜单配置
+    function checkMoudle(menuItem) {
+      const { moduleType } = menuItem;
+      assert(moduleType);
+      if (moduleType === 'iframe') {
+        assert(menuItem.iframeConfig);
+        assert(menuItem.iframeConfig.path !== undefined);
+      } else if (moduleType === 'custom') {
+        assert(menuItem.customConfig);
+        assert(menuItem.customConfig.path !== undefined);
+      } else if (moduleType === 'sider') {
+        const { siderConfig } = menuItem;
+        assert(siderConfig);
+        assert(siderConfig.menu);
+        siderConfig.menu.forEach((subMenuItem) => {
+          checkMenuItem(subMenuItem);
+        });
+      } else if (moduleType === 'schema') {
+        const { schemaConfig } = menuItem;
+        assert(schemaConfig);
+        assert(schemaConfig.api !== undefined);
+        assert(schemaConfig.schema);
+      }
+    }
+  });
+});