@dmqweb/elpis 1.0.0

package/elpis-core/loader/router.js

@@ -0,0 +1,52 @@
+const KoaRouter = require("koa-router")
+const path = require("path")
+const glob = require("glob")
+const {sep} = path
+
+/**
+ * router loader
+ * @param {object} app Koa 实例
+ *  
+ * 解析所有 app/router/ 路径下的所有js文件 加载到 KoaRouter 下
+ */
+module.exports = (app) => {
+  // 创建路由实例
+  const router = new KoaRouter()
+
+  //获取所有 elpis 路由文件
+  const elpisRouterPath = path.resolve(__dirname, `..${sep}..${sep}app${sep}router`)
+  // 注册所有 elpis 路由
+  const elpisRouterFileList = glob.sync(path.resolve(elpisRouterPath, `.${sep}**${sep}*.js`))
+  elpisRouterFileList.forEach(file => {
+    // 加载路由模块，并传入app实例和router实例
+    require(path.resolve(file))(app,router)
+  })
+  
+  //获取所有业务路由文件
+  const businessRouterPath = path.resolve(app.businessPath, `.${sep}router`)
+  // 注册所有业务路由
+  const businessRouterFileList = glob.sync(path.resolve(businessRouterPath, `.${sep}**${sep}*.js`))
+  businessRouterFileList.forEach(file => {
+    // 加载路由模块，并传入app实例和router实例
+    require(path.resolve(file))(app,router)
+  })
+
+  // 根路径重定向到首页
+  router.get('/', async (ctx,next) => {
+    ctx.status = 302;
+    ctx.redirect(app?.options?.homePage ?? '/view/project-list');
+  });
+
+  // 路由兜底 - 放在最后确保其他路由优先匹配（健壮性）
+  router.get('/view/*', async (ctx,next) => {
+    ctx.status = 302;
+    ctx.redirect(`${app?.options?.homePage ?? './'}`);
+  });
+
+  // 将路由实例保存到app对象上，方便调试
+  app.router = router
+  
+  // 注册路由实例
+  app.use(router.routes())
+  app.use(router.allowedMethods())
+}

package/elpis-core/loader/service.js

@@ -0,0 +1,74 @@
+const path = require('path')
+const glob = require('glob')
+const { sep } = path
+
+/**
+ * service loader
+ * @param {object} app Koa 实例
+ * 
+ * 加载所有 service 可通过 'app.service.${目录}.${文件名}' 访问' 
+ * 
+ * 例如
+ * app/service
+ *    |
+ *    | -- custom-moudle
+ *               |
+ *               | -- costom-service.js 
+ * => app.service.customMoudle.costomService
+ */ 
+
+module.exports = (app) => {
+  const service = {}; 
+
+  // 拼接eplis内部的service配置
+  const elpisServicePath = path.resolve(__dirname, `..${sep}..${sep}app${sep}service`);
+  // 使用glob模式匹配查找所有嵌套目录下的.js文件 (**表示任意层级子目录)
+  const elpisServiceFileList = glob.sync(path.resolve(elpisServicePath, `.${sep}**${sep}**.js`));
+  elpisServiceFileList.forEach(handleFile);
+
+  // 业务层app下配置的services
+  const businessServicePath = path.resolve(app.businessPath, `.${sep}service`);
+  // 使用glob模式匹配查找所有嵌套目录下的.js文件 (**表示任意层级子目录)
+  const businessServiceFileList = glob.sync(path.resolve(businessServicePath, `.${sep}**${sep}**.js`));
+
+  // 遍历所有文件目录，把内容加载到app.service 下
+  businessServiceFileList.forEach(handleFile);
+  function handleFile(file) {
+    // 提取文件名
+    let name = path.resolve(file);
+
+    // 截取路径 => app/service/custom-moudle/costom-service.js => custom-moudle/costom-service
+    name = name.substring(name.lastIndexOf(`service${sep}`) + `service${sep}`.length, name.lastIndexOf('.'))
+
+    // 把'-'统一成驼峰式,custom-moudle/costom-service => customMoudle/costomService
+    name = name.replace(/[_-][a-z]/ig, (s) => s.substring(1).toUpperCase());
+
+    // 挂载 service 到内容 app 对象中
+
+    // 创建临时引用指向服务层容器，用于构建嵌套结构
+    let tempService = service
+    // 将服务层路径按分隔符分割成数组，例如 'user/auth' => ['user'(目录), 'auth'(文件)]
+    const names = name.split(sep);
+    // 遍历路径数组，构建层次化的对象结构
+    for (let i = 0; i < names.length; i++){
+       // 判断是否为最后一层
+      if (i === names.length - 1){
+        // 创建服务层实例对象
+        // 1. 加载服务层模块并传入app实例，获取返回的服务层类
+        const serviceMoule = require(path.resolve(file))(app);
+        // 2. 实例化服务层类，创建具体的服务层对象实例
+        tempService[names[i]] = new serviceMoule();     
+      }else{
+        // 处理服务层目录结构
+        // 如果当前层级的对象不存在，则创建空对象
+        if (!tempService[names[i]]){
+          tempService[names[i]] = {}
+        }
+        // 将临时引用指向下一层级，继续构建更深层的结构
+        tempService = tempService[names[i]]
+      }
+    }
+  };
+  // 挂载 middlewares 到内容 app 对象中
+  app.service = service;
+} 

package/index.js

@@ -0,0 +1,29 @@
+// 引入elpis-core
+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")
+  },
+  // 启动elpis，传入配置文件
+  serverStart(options={}){
+    // 启动项目
+    const app = ElpisCore.start(options);
+    return app;
+  },
+  // 编译构建前端工程
+  frontendBuild(env){
+    if(env === "local"){
+      FEBuildDev();
+    }else if(env === "production"){
+      FEBuildProd();
+    }
+  }
+}

package/jsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "ES2022",
+    "jsx": "react-jsx",
+    "allowImportingTsExtensions": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true
+  },
+  "exclude": [
+    "node_modules",
+    "**/node_modules/*",
+    "docs/dashboard-model.js"
+  ]
+}

package/logs/applocation.log

@@ -0,0 +1,3 @@
+[2025-09-28T15:38:14.660] [INFO] default - [GET /api/project/list] signature: 10471f4ee0aabb01d1a3a69247742653
+[2025-09-28T15:38:14.664] [INFO] default - [GET /api/project] signature: 10471f4ee0aabb01d1a3a69247742653
+[2025-09-28T15:38:14.666] [INFO] default - [GET /api/project/model_list] signature: 10471f4ee0aabb01d1a3a69247742653

package/model/index.js

@@ -0,0 +1,119 @@
+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, projectValue) => {
+    // 如果modelValue和projectValue都是数组
+    // 处理数组合并的特殊情况
+    if (Array.isArray(modelValue) && Array.isArray(projectValue)){
+      let result = []
+
+      // 因为 project 继承 model，所以需要处理修改和新增内容的情况
+      // project有的键值， model也有，则修改 （重载）
+      // project有的键值， model中没有，则添加 (扩展)
+      // model有的键值， project中没有，则保留 （继承）
+
+      // 处理修改和保留
+      for(let i = 0; i < modelValue.length; i++) {
+        // 获取menu数据
+        let modelItem = modelValue[i];
+        // 获取和modelitem里的key值相同的projectitem
+        const projectItem = projectValue.find(projectItem => projectItem.key === modelItem.key )
+
+        // 如果匹配到相同的projectItem，则进行递归继承，没有则保留
+        result.push(projectItem ? projectExtendModel(modelItem, projectItem) : modelItem)
+      }
+
+      // 处理新增
+      for(let i = 0; i < projectValue.length; i++) {
+        const projectItem = projectValue[i];
+        const modelItem = modelValue.find(modelItem => modelItem.key === projectItem.key)
+        if (!modelItem) {
+          result.push(projectItem)
+        }
+      }
+      return result
+    }
+    return undefined;
+  })
+}
+
+/**
+* 解析 model 配置， 并返回组织且继承后的数据结构
+* [{
+*   model: ${model};
+*   project:{
+*     proj1Key: ${proj1},
+*     proj2Key: ${proj2}
+*   }
+* }, ...]
+*
+*/
+
+ // 导出一个函数，接收app参数，用于构建model数据结构
+module.exports = (app) => {
+  const modelList = [];
+
+  // 遍历当前文件夹，构造模型数据结构，挂载到 modelList 上 
+  const modelPath = path.resolve(process.cwd(), `.${sep}model`);
+  const fileList = glob.sync(path.resolve(modelPath, `.${sep}**${sep}**.js`));
+  fileList.forEach(file => {
+    // 跳过当前文件(index.js)自身
+    if (file.indexOf('index.js') > -1) {  return; }
+
+    // 区分 model 文件和 project 文件
+    const type = file.includes(`${sep}project${sep}`) || file.includes('/project/') || file.includes('\\project\\') ? 'project' : 'model';
+
+     // 处理project类型的文件
+    if (type === 'project') {
+      // 从文件路径中提取model名称，例如从 model/business/project/pdd.js 提取 business
+      const modelKey = file.match(/model[/\\]([^/\\]+)[/\\]project/)?.[1];
+      // 从文件路径中提取project名称，例如从 model/business/project/pdd.js 提取 pdd
+      const projectKey = file.match(/project[/\\]([^/\\]+)\.js/)?.[1];
+      
+      // 在modelList中查找是否已存在该modelKey对应的modelItem
+      let modelItem = modelList.find(item => item.model?.key === modelKey)
+      // 如果没有找到对应的modelItem，则创建一个新的对象并添加到modelList中
+      if ( !modelItem ) {
+        modelItem = {};
+        modelList.push(modelItem);
+      }
+      // 如果modelItem还没有project属性，则初始化为空对象
+      if ( !modelItem.project ) {
+        modelItem.project = {};
+      }
+      // 加载project文件内容，并将其添加到modelItem.project对象中，以projectKey为键
+      modelItem.project[projectKey] = require(path.resolve(file));
+      // 为加载的project对象添加key属性，标识其名称
+      modelItem.project[projectKey].key = projectKey
+      modelItem.project[projectKey].modelKey = modelKey
+    }
+
+    // 处理model类型的文件
+    if (type === 'model') {
+      const modelKey = file.match(/[/\\]model[/\\](.*?)[/\\]model\.js/)?.[1]
+      let modelItem = modelList.find(item => item.model?.key === modelKey)
+      if ( !modelItem ) {
+        modelItem = {};
+        modelList.push(modelItem);
+      }
+      // 加载model文件内容，并将其赋值给modelItem.model
+      modelItem.model = require(path.resolve(file));
+      // 为加载的model对象添加key属性，标识其名称
+      modelItem.model.key = modelKey
+    }
+  })
+
+  // 数据进一步整理 project => 继承 model
+  modelList.forEach(item => {
+    const {model, project} = item;
+    for (const projectKey in project){
+      project[projectKey] = projectExtendModel(model, project[projectKey])
+    }
+  })
+
+  return modelList;
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@dmqweb/elpis",
+  "version": "1.0.0",
+  "description": "",
+  "repository": {
+    "type": "git",
+    "url": "https://git.code.tencent.com/dumingqing/Elpis.git"
+  },
+  "license": "ISC",
+  "author": "dumingqing",
+  "main": "index.js",
+  "scripts": {
+    "test": "set _ENV=local&& mocha test/**/*.js",
+    "lint": "eslint --quiet --ext js,vue ."
+  },
+  "dependencies": {
+    "@babel/core": "^7.24.0",
+    "@babel/runtime": "^7.28.4",
+    "@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",
+    "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": "^2.3.5",
+    "url-loader": "^4.1.1",
+    "vue-eslint-parser": "^10.2.0",
+    "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-parser": "^7.28.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-vue": "^9.33.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,216 @@
+const assert = require('assert');
+const supertest = require('supertest');
+const md5 = require('md5');
+const elpisCore = require('../../elpis-core');
+
+const signKey = 'elpis-sign-key';
+const st = Date.now();
+
+// 测试套件：测试 project 相关接口
+describe('测试 project 相关接口', function () { 
+  this.timeout(5000);
+
+  let request;  
+  let modelList;
+  let projectList = [];
+
+  // 启动应用
+  it('启动' , async () => { 
+    const app = await elpisCore.start();
+    modelList = require('../../model/index.js')(app);
+    modelList.forEach(modelItem => {
+      const { project } = modelItem;
+      for(const projKey in project) {
+        projectList.push(project[projKey]);
+      }
+    })
+    request = supertest(app.listen());
+  })
+
+  // 测试获取项目配置接口不带projectKey
+  it('GET /api/project/list without projectKey', 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') > -1 )
+})
+// 测试获取项目配置接口带错误projectKey
+  it('GET /api/project/list  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: 'xxxx'
+    })
+    const res = await tmpRequest;
+    assert(res.body.success === false)
+
+    const resBody = res.body;
+    assert(resBody.code === 5000);
+    assert(resBody.message === '项目获取异常' )
+})
+// 测试获取项目配置接口带正确projectKey
+  it('GET /api/project/list with projectKey', async () => { 
+    for (let i = 0; i < projectList.length; i++) {
+    const projItem = projectList[i]; 
+    const { key:projKey } = projItem;
+    console.log(`GET /api/project/list with proj_key: ${projKey}` )
+     
+    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.proj_key === projKey)
+    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/list with proj_key -menuKey: ', menuItem.key)
+      assert(menuItem.key)
+      assert(menuItem.name)
+      assert(menuItem.menuType) 
+      if (menuItem.moduleType === 'group') {
+        assert(menuItem.subMenu !== undefined)
+        menuItem.subMenu.forEach(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(siderMenuItem => {
+          checkMenuItem(siderMenuItem)
+        })
+      }
+
+      if (moduleType === 'custom'){
+        const { customConfig } = menuItem
+        assert(customConfig)
+        assert(customConfig.path !== undefined) 
+      }
+
+      if (moduleType === 'schema'){
+        const { schemaConfig } = menuItem
+        assert(schemaConfig)
+        assert(schemaConfig.api !== undefined) 
+        assert(schemaConfig.schema) 
+      }
+
+      if (moduleType === 'iframe'){
+        const { iframeConfig } = menuItem
+        assert(iframeConfig)
+        assert(iframeConfig.path !== undefined) 
+      }
+
+    }
+  })  
+  
+
+  // 测试获取项目列表接口不带proejctKey
+  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++) { 
+      // name, desc, homePage, key, modelkey
+      const item = resData[i];
+      assert(item.name)
+      assert(item.key)
+      assert(item.desc !== undefined)
+      assert(item.homePage !== undefined)
+      assert(item.modelKey)
+    }
+})
+  it('GET /api/project/list with proj_key', async () => { 
+    // 随机获取一个项目key
+    const { key:projKey } = projectList[Math.floor(Math.random() * projectList.length)]
+    console.log(`GET /api/project/list with proj_key: ${projKey}` )
+    const { modelKey } = 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++) { 
+      // name, desc, homePage, key, modelkey
+      const item = resData[i];
+      assert(item.name)
+      assert(item.key)
+      assert(item.desc !== undefined)
+      assert(item.homePage !== undefined)
+      assert(item.modelKey)
+    } 
+})
+
+  // 测试获取项目模型列表接口
+  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;
+    
+    // console.log(JSON.stringify(res.body))
+    // 验证响应结果
+    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.name)
+      assert(item.model.key)
+      assert(item.project)
+      for (const projectKey in item.project) { 
+        assert(item.project[projectKey].name)
+        assert(item.project[projectKey].key)
+      }
+    }
+  })
+
+  
+});