q-koa 7.7.2

package/core/app.js

@@ -0,0 +1,1813 @@
+const Koa = require('koa')
+const Router = require('koa-router')
+const _ = require('lodash')
+const path = require('path')
+const fs = require('fs')
+const Sequelize = require('sequelize')
+const moment = require('moment')
+const { EventEmitter } = require('events')
+const nodeVm = require('vm')
+const LRU = require('lru-cache')
+
+const { Serve } = require('static-koa-router')
+
+const rootDirectory = process.cwd()
+const ora = require('ora')
+const chalk = require('chalk')
+const { Random } = require('mockjs')
+const util = require('util')
+const jwt = require('jsonwebtoken')
+const fsExtra = require('fs-extra')
+const { getObject } = require('./file/utils')
+const restc = require('./restc')
+const APP_DIR = 'app'
+const PLUGINS_DIR = 'plugins'
+const {
+  miErrors,
+  miSend,
+  miStatic,
+  // miProxy,
+  miAgent,
+  miResponse,
+  miCors,
+  miBody,
+  miXmlBody,
+  miCompress,
+  miBodyParser,
+  miWebsocket,
+  miLimit,
+} = require('./middlewares')
+const Validator = require('./validator')
+
+let spinner
+
+const starter = new EventEmitter()
+
+const formatPostFunction = (str) => `eval(${str})`
+
+const connectDatabase = (database) => (config) => {
+  if (!database) throw new Error('请配置数据库名称')
+  if (!config.username) throw new Error('请配置数据库账号')
+  if (!config.password) throw new Error('请配置密码')
+  if (!config.host) throw new Error('请配置数据库地址')
+  // @ts-ignore
+  const db = new Sequelize(database, config.username, config.password, {
+    host: config.host,
+    dialect: config.dialect,
+    port: config.port,
+    logging: config.logging,
+    timezone: config.timezone,
+    operatorsAliases: config.operatorsAliases,
+    pool: config.pool,
+  })
+  return db
+}
+
+const defaultConfig = require('./config')
+
+class APP {
+  constructor(_config) {
+    const config = _.defaultsDeep(_config, defaultConfig)
+    const { port } = config
+    this.config = config
+    this.port = port
+    this.app = new Koa()
+    this.server = null
+    this.middlewares = [
+      ..._.get(config, 'middlewares', []),
+      miLimit(config.rateLimit),
+      miStatic(config.static),
+      miAgent(),
+      miWebsocket(),
+      miCors(config.includes, config.ip),
+      // miRestc(config),
+      miBody(config.koaBody),
+      miXmlBody(config.xmlBody),
+      miBodyParser(config.bodyParser),
+
+      miCompress(),
+      // miProxy(),
+      miSend(),
+      miResponse(config.response),
+      // miToken(),
+      miErrors(),
+    ]
+  }
+
+  async start() {
+    console.log(chalk.green('==================== start ===================='))
+    spinner = ora('Loading unicorns').start()
+    spinner.color = 'yellow'
+    spinner.text = ' '
+    this.middlewares.forEach((middleware) => {
+      this.app.use(middleware)
+    })
+    // this.app.use(cors({
+    //   origin: 'http://0.0.0.0:3078',
+    //   credentials: true,
+    // }));
+    const { is_off = false } = this.config.restc
+    if (!is_off) {
+      this.app.use((ctx, next) => {
+        const { url } = ctx.request
+        const appName = url.split('/')[1]
+        const excludes = [
+          ...this.config.restc.excludes,
+          ..._.get(ctx.app[appName], 'appConfig.restc.excludes', []).map(
+            (item) => `/${appName}/${item}`
+          ),
+        ]
+        this.app.use(
+          restc.koa2({
+            excludes,
+          })
+        )
+        return next()
+      })
+    }
+
+    /**
+     *  jwt中间件
+     */
+    this.app.use(async (ctx, next) => {
+      const verify = util.promisify(jwt.verify)
+      const { url, host, ip, method } = ctx.request
+      const appName = url.split('/')[1]
+      const { secret, whiteList, _whiteList, tokenKey, expiresIn } =
+        ctx.app[appName] && ctx.app[appName].appConfig
+          ? ctx.app[appName].appConfig.jwt
+          : {
+              secret: 'token',
+              tokenKey: 'token',
+              expiresIn: '200000000',
+              _whiteList: [],
+              whiteList: [
+                'find',
+                'administrator/login',
+                'administrator/checkLogin',
+                'user/checkLogin',
+                'user/login',
+                'user/register',
+                'common',
+                'good/search',
+                'category/tree',
+                'system',
+              ],
+            }
+
+      /**
+       *  挂在jwt解密方法
+       */
+      if (this.app[appName]) {
+        this.app[appName].sign = async (user) => {
+          const result = await jwt.sign(user, secret, {
+            expiresIn,
+          })
+          return result
+        }
+      }
+      // eslint-disable-next-line no-nested-ternary
+      ctx.request.clientType = ctx.header['client-type']
+        ? Number(ctx.header['client-type'])
+        : host.startsWith('localhost')
+        ? 0
+        : 99
+
+      const token =
+        ctx.header[`${appName}-${tokenKey}`] ||
+        ctx.cookies.get(`${appName}-${tokenKey}`) ||
+        ctx.query[`${appName}-${tokenKey}`]
+
+      if (url.length > 2) {
+        console.log(
+          moment().format('HH:mm:ss'),
+          url,
+          host,
+          ctx.request.clientType
+        )
+      }
+
+      try {
+        const { user } = await verify(token, secret)
+        if (user) {
+          console.log('user id ---> ', appName, '--->', user.id, user.name)
+          ctx.request[`${appName}-user`] = user
+        }
+      } catch (e) {
+        const combineWhiteList = Array.from(
+          new Set([...whiteList, ..._whiteList])
+        )
+        const pass = combineWhiteList.some(
+          (link) => link !== '/' && url.includes(link)
+        )
+
+        if (
+          pass ||
+          url === `/${appName}/` ||
+          method === 'GET' ||
+          url.includes('.') ||
+          ctx.request.clientType === 0
+        ) {
+          return await next()
+        }
+        throw new Error('没有权限或登录失效，请重新登录')
+      }
+      await next()
+    })
+
+    this.initApp()
+
+    this.app.on('error', async (err, ctx) => {
+      const { url } = ctx.request
+      const appName = url.split('/')[1]
+      const errorData = {
+        url: ctx.request.href,
+        body: ctx.request.body,
+        message: err.message,
+        content: err.stack,
+        header: ctx.request.header,
+      }
+      if (
+        this.app &&
+        this.app[appName] &&
+        this.app[appName].model &&
+        this.app[appName].model.log
+      ) {
+        this.app[appName].model.log.upsert(errorData)
+      }
+      throw new Error(err)
+    })
+
+    // this.app.on('message', async (content) => {
+    //   console.log(content);
+    // });
+
+    starter.on('loadAll', () => {
+      const appName = this.config.includes[0]
+      this.server = this.app.listen(this.port, () => {
+        console.log(`server is running at http://localhost:${this.port}`)
+        console.log(
+          `first app is http://localhost:3001/${appName}/setting/findOne`
+        )
+      })
+
+      if (process.env.NODE_ENV !== 'production') {
+        if (
+          this.app[appName].service.model &&
+          this.app[appName].service.model.loadModel
+        ) {
+          this.app[appName].service.model.loadModel({
+            app: this.app[appName],
+            appName: appName,
+          })
+        } else {
+          fs.writeFileSync(
+            `${rootDirectory}/${APP_DIR}/${appName}/${PLUGINS_DIR}/model/service.js`,
+            ''
+          )
+          this.start()
+        }
+      }
+
+      process.on('exit', (code) => {
+        console.log(`[exit custom], About to exit with code: ${code}`)
+      })
+      if (process.env.NODE_ENV === 'production') {
+        if (
+          this.app[appName].service.cache &&
+          this.app[appName].service.cache.init
+        ) {
+          this.app[appName].service.cache.init({
+            app: this.app[appName],
+            appName: appName,
+          })
+        }
+        process.on('SIGINT', () => {
+          console.log('Closing server...')
+          this.server.close(() => {
+            console.log('Server closed !!! ')
+            process.exit()
+          })
+        })
+      }
+    })
+  }
+
+  async initApp() {
+    let dirList = fs.readdirSync(
+      path.resolve(__dirname, `${rootDirectory}/${APP_DIR}`)
+    )
+    dirList = dirList.filter((item) => this.config.includes.includes(item))
+
+    let dbFlag = false
+    for (let i = 0; i < dirList.length; i++) {
+      const appName = dirList[i]
+
+      console.log(
+        chalk.green(`==================== 启动 ${appName} ====================`)
+      )
+      const routerConfig = {
+        prefix: `/${appName}`,
+      }
+      const router = new Router(routerConfig)
+      Serve(
+        path.resolve(
+          __dirname,
+          `${rootDirectory}/${APP_DIR}/${appName}/public`
+        ),
+        router
+      )
+
+      try {
+        const db = connectDatabase(appName)(this.config.db)
+        if (process.env.NODE_ENV === 'production') {
+          if (!dbFlag) {
+            console.log(chalk.green(`检查${appName}数据库`))
+            await db.authenticate()
+            dbFlag = true
+          }
+        } else {
+          console.log(chalk.green(`检查${appName}数据库`))
+          await db.authenticate()
+        }
+        const configPath = `${rootDirectory}/${APP_DIR}/${appName}/config.js`
+        const configFile = path.resolve(__dirname, configPath)
+        const configExist = fs.existsSync(configFile)
+
+        this.app[appName] = {
+          sequelize: db,
+          appConfig: _.defaultsDeep(
+            configExist ? require(path.resolve(__dirname, configPath)) : {},
+            this.config.app
+          ),
+        }
+
+        // const proxyConfig = _.get(this.app[appName], 'appConfig.proxy');
+        const taskConfig = _.get(this.app[appName], 'appConfig.task', {
+          is_available: false,
+        })
+        // if (proxyConfig) {
+        //   this.app.use(proxy(`/${appName}`, proxyConfig));
+        // }
+
+        const initFileConfig = _.get(
+          this.app[appName],
+          'appConfig.initFile',
+          false
+        )
+        if (initFileConfig) {
+          this.initFile(appName)
+        }
+
+        this.initPlugin(appName)
+        this.app[appName].event = new EventEmitter()
+
+        const cacheConfig = _.get(this.app[appName], 'appConfig.cache', {
+          max: 100,
+          maxAge: 1000 * 60 * 60 * 24,
+        })
+
+        this.app[appName].cache = new LRU({
+          max: cacheConfig.max,
+          maxAge: cacheConfig.maxAge,
+        })
+
+        this.initModel(appName)
+        // const models = Object.keys(this.app[appName].model).join(' / ')
+        if (taskConfig.is_available) {
+          this.initTask(appName)
+        }
+      } catch (e) {
+        console.log(`${appName}数据库连接失败`)
+        console.log(e)
+        throw new Error(e)
+      }
+      if (
+        this.app[appName] &&
+        this.app[appName].appConfig &&
+        this.app[appName].appConfig.router
+      ) {
+        this.app[appName].appConfig.router(router)(this.app[appName])
+      }
+      this.initRouter(router)
+      this.app.use(router.routes()).use(router.allowedMethods())
+    }
+
+    const router = new Router()
+    if (this.config.router) {
+      this.config.router(router)
+    }
+    router.post('*', () => {
+      throw new Error('接口路径不符合规范')
+    })
+    this.app.use(router.routes()).use(router.allowedMethods())
+
+    spinner.stop()
+
+    console.log(chalk.green('==================== end ===================='))
+    starter.emit('loadAll')
+  }
+
+  initFile(appName) {
+    const dirExist = fsExtra.existsSync(path.resolve(__dirname, './file'))
+    if (dirExist) {
+      fsExtra.copySync(
+        path.resolve(__dirname, './file'),
+        path.resolve(__dirname, `${rootDirectory}/${APP_DIR}/${appName}`),
+        {
+          clobber: false,
+        }
+      )
+    }
+  }
+
+  initTask(appName) {
+    console.log(chalk.red(`启动任务${appName}`))
+    const taskDir = path.resolve(
+      __dirname,
+      `${rootDirectory}/${APP_DIR}/${appName}/task`
+    )
+    const publicExist = fs.existsSync(taskDir)
+    if (!publicExist) fs.mkdirSync(taskDir)
+    fs.readdirSync(taskDir).forEach((folder) => {
+      const isFolder = fs.lstatSync(path.resolve(taskDir, folder)).isDirectory()
+      if (isFolder) {
+        fs.readdirSync(path.resolve(taskDir, folder)).forEach((filename) => {
+          if (filename === 'index.js') {
+            const task = require(path.resolve(
+              __dirname,
+              `${rootDirectory}/${APP_DIR}/${appName}/task/${folder}`
+            ))
+            this.app[appName] = _.defaultsDeep(
+              {
+                task,
+              },
+              this.app[appName]
+            )
+          }
+        })
+      }
+    })
+  }
+
+  initPlugin(appName) {
+    const pluginDir = path.resolve(
+      __dirname,
+      `${rootDirectory}/${APP_DIR}/${appName}/${PLUGINS_DIR}`
+    )
+    const publicExist = fs.existsSync(pluginDir)
+    if (!publicExist) fs.mkdirSync(pluginDir)
+
+    fs.readdirSync(pluginDir).forEach((folder) => {
+      const isFolder = fs
+        .lstatSync(path.resolve(pluginDir, folder))
+        .isDirectory()
+      if (isFolder) {
+        fs.readdirSync(path.resolve(pluginDir, folder)).forEach((filename) => {
+          const extname = path.extname(filename)
+          if (extname === '.js') {
+            const n = path.basename(filename, extname)
+            if (
+              [
+                'model',
+                'controller',
+                'service',
+                'validate',
+                'config',
+                'beforeValidate',
+                'afterValidate',
+                'afterExecute',
+              ].includes(n)
+            ) {
+              if (n === 'model') {
+                const defaultModelPath = path.resolve(
+                  __dirname,
+                  `./file/${PLUGINS_DIR}/${folder}`,
+                  `${filename}`
+                )
+                const defaultModelExist = fs.existsSync(defaultModelPath)
+                const currentAttributes = require(path.resolve(
+                  pluginDir,
+                  folder,
+                  filename
+                ))
+                const _attributes =
+                  Object.keys(currentAttributes).length === 0 &&
+                  defaultModelExist
+                    ? require(defaultModelPath)
+                    : currentAttributes
+
+                const belongs = _.get(
+                  this.app[appName].config[folder],
+                  'belongs',
+                  'page'
+                )
+
+                const _id =
+                  belongs === 'setting'
+                    ? {
+                        id: {
+                          type: Sequelize.TINYINT.UNSIGNED,
+                          allowNull: false,
+                          primaryKey: true,
+                          autoIncrement: true,
+                        },
+                      }
+                    : {
+                        id: {
+                          type: Sequelize.MEDIUMINT.UNSIGNED,
+                          allowNull: false,
+                          primaryKey: true,
+                          autoIncrement: true,
+                        },
+                      }
+
+                const attributes = _.defaultsDeep(_.cloneDeep(_attributes), {
+                  ..._id,
+                  createdid: {
+                    type: Sequelize.MEDIUMINT.UNSIGNED,
+                    allowNull: false,
+                    defaultValue: 0,
+                  },
+                  created_at: {
+                    type: Sequelize.DATE,
+                    allowNull: false,
+                    // defaultValue: Sequelize.literal('CURRENT_TIMESTAMP'),
+                    comment: '生成时间',
+                  },
+                  updated_at: {
+                    type: Sequelize.DATE,
+                    allowNull: false,
+                    // defaultValue: Sequelize.literal('CURRENT_TIMESTAMP'),
+                    comment: '修改时间',
+                  },
+                })
+
+                this.app[appName].attributes = {
+                  ...this.app[appName].attributes,
+                  [folder]: _attributes,
+                }
+
+                const instance = this.app[appName].sequelize.define(
+                  folder,
+                  attributes,
+                  {
+                    freezeTableName: true,
+                    comment: folder,
+                    // timestamps: !modelConfig.belongs === 'setting',
+                    createdAt: 'created_at',
+                    updatedAt: 'updated_at',
+                    name: {
+                      singular: folder,
+                      plural: `${folder}s`,
+                    },
+                    hooks: {
+                      beforeCreate: (res, t) => {
+                        try {
+                          if (res.toJSON().user_id) {
+                            res.createdid = res.toJSON().user_id
+                          }
+                        } catch (e) {
+                          console.log(e)
+                        }
+                      },
+                    },
+                  }
+                )
+                instance.getName = function () {
+                  return folder
+                }
+                this.app[appName] = _.defaultsDeep(
+                  {
+                    [n]: {
+                      [folder]: instance,
+                    },
+                  },
+                  this.app[appName]
+                )
+                const mockObj = _.pickBy(
+                  _attributes,
+                  (item) => item.mock && typeof item.mock === 'function'
+                )
+                this.app[appName] = _.defaultsDeep(
+                  {
+                    mock: {
+                      [folder]: () =>
+                        _.zipObject(
+                          Object.keys(mockObj),
+                          Object.keys(mockObj).map((key) =>
+                            _.result(mockObj, `${key}.mock`)
+                          )
+                        ),
+                    },
+                  },
+                  this.app[appName]
+                )
+              } else if (
+                ['controller', 'validate', 'afterExecute', 'service'].includes(
+                  n
+                )
+              ) {
+                const defaultPath = path.resolve(
+                  __dirname,
+                  `./file/${PLUGINS_DIR}/${folder}`,
+                  `${filename}`
+                )
+                const defaultExist = fs.existsSync(defaultPath)
+                const defaultN = !defaultExist
+                  ? Object.create(null)
+                  : {
+                      [n]: {
+                        [folder]: defaultExist
+                          ? require(path.resolve(
+                              __dirname,
+                              `./file/${PLUGINS_DIR}/${folder}`,
+                              `${filename}`
+                            ))
+                          : null,
+                      },
+                    }
+                this.app[appName] = _.defaultsDeep(
+                  {
+                    [n]: {
+                      [folder]: require(path.resolve(
+                        pluginDir,
+                        `${folder}`,
+                        `${filename}`
+                      )),
+                    },
+                  },
+                  defaultN,
+                  this.app[appName]
+                )
+              } else {
+                this.app[appName] = _.defaultsDeep(
+                  {
+                    [n]: {
+                      [folder]: require(path.resolve(
+                        pluginDir,
+                        `${folder}`,
+                        `${filename}`
+                      )),
+                    },
+                  },
+                  this.app[appName]
+                )
+              }
+            }
+          }
+        })
+      }
+    })
+  }
+
+  initModel(appName) {
+    for (let i = 0; i < Object.keys(this.app[appName].model).length; i++) {
+      const model = Object.keys(this.app[appName].model)[i]
+
+      if (!this.app[appName].include || !this.app[appName].include[model]) {
+        this.app[appName] = _.defaultsDeep(
+          {
+            include: {
+              [model]: [],
+            },
+          },
+          this.app[appName]
+        )
+      }
+      const db = this.app[appName].attributes[model]
+
+      const list = Object.keys(db)
+        .filter((item) => item.endsWith('_id'))
+        .map((item) => item.match(/(.*)_id/)[1])
+
+      list.forEach((model1) => {
+        if (this.app[appName].attributes[model][`${model1}_id`].belongsTo) {
+          const myModel = this.app[appName].attributes[model][`${model1}_id`]
+            .belongsTo
+          this.app[appName].model[model].belongsTo(
+            this.app[appName].model[myModel],
+            {
+              as: model1,
+              foreignKey: `${model1}_id`,
+              constraints: false,
+            }
+          )
+          this.app[appName].include[model].push({
+            model: this.app[appName].model[myModel],
+            as: model1,
+          })
+        }
+
+        if (!this.app[appName].include[model1]) {
+          this.app[appName].include[model1] = []
+        }
+        if (!this.app[appName].include[model]) {
+          this.app[appName].include[model] = []
+        }
+        if (model1 === 'parent') {
+          this.app[appName].model[model].belongsTo(
+            this.app[appName].model[model],
+            {
+              as: 'parent',
+              foreignKey: 'parent_id',
+              constraints: false,
+            }
+          )
+          this.app[appName].include[model].push({
+            model: this.app[appName].model[model],
+            as: 'parent',
+          })
+        }
+
+        if (model1 && this.app[appName].model[model1]) {
+          this.app[appName].model[model].hasOne(
+            this.app[appName].model[model1],
+            {
+              foreignKey: 'id',
+              sourceKey: `${model1}_id`,
+              constraints: false,
+            }
+          )
+          this.app[appName].include[model].push({
+            model: this.app[appName].model[model1],
+          })
+          if (
+            this.app[appName].attributes[model][`${model1}_id`].hasOne &&
+            this.app[appName].attributes[model][`${model1}_id`].hasOne === true
+          ) {
+            this.app[appName].model[model1].hasOne(
+              this.app[appName].model[model],
+              {
+                foreignKey: `${model1}_id`,
+                targetKey: 'id',
+                constraints: false,
+              }
+            )
+          } else {
+            this.app[appName].model[model1].hasMany(
+              this.app[appName].model[model],
+              {
+                foreignKey: `${model1}_id`,
+                targetKey: 'id',
+                constraints: false,
+              }
+            )
+          }
+          // this.app.include[model1].push({ model: app.model[model] });
+        }
+      })
+    }
+  }
+
+  initRouter(router) {
+    router.post('/:controller', async (ctx, next) => {
+      const appName = router.opts.prefix.substring(1)
+      const { app } = ctx
+      const { controller } = ctx.params
+      if (
+        !_.get(app, `${appName}.model.${controller}`) ||
+        !_.get(app, `${appName}.controller.${controller}`)
+      ) {
+        throw new Error('路由model定义缺失')
+      }
+      await next()
+    })
+    router.post('/:controller/:fn', async (ctx) => {
+      const appName = router.opts.prefix.substring(1)
+      const { app } = ctx
+
+      const { controller, fn } = ctx.params
+      if (_.get(app, `${appName}.model.${controller}`) && fn === 'mock') {
+        return ctx.SUCCESS(await app[appName].mock[controller]())
+      }
+
+      if (
+        !_.get(app, `${appName}.model.${controller}.${fn}`) &&
+        !_.get(app, `${appName}.controller.${controller}.${fn}`)
+      ) {
+        throw new Error('路由fn定义缺失')
+      }
+
+      const cacheModel = _.get(ctx.app[appName], 'appConfig.cacheModel', [])
+
+      if (fn === 'updateSort') {
+        if (cacheModel.includes(controller)) {
+          ctx.app[appName].cache.set(`${controller}`, null)
+        }
+      }
+
+      if (_.get(app, `${appName}.controller.${controller}.${fn}`)) {
+        const hooksList = [
+          'beforeValidate',
+          'validate',
+          'afterValidate',
+          'controller',
+          'afterExecute',
+        ]
+        for (let i = 0; i < hooksList.length; i++) {
+          if (_.get(app, `${appName}.${hooksList[i]}.${controller}.${fn}`)) {
+            await app[appName][hooksList[i]][controller][fn](ctx)
+          }
+        }
+
+        return true
+      }
+
+      if (
+        _.get(app, `${appName}.model.${controller}`) &&
+        [
+          'findOne',
+          'findAll',
+          'findAndCountAll',
+          'create',
+          'upsert',
+          'destroy',
+          'bulkCreate',
+          'count',
+        ].includes(fn)
+      ) {
+        const excludeAuth =
+          _.get(app, `${appName}.config.${controller}.excludeAuth`) || []
+        if (excludeAuth.includes(fn) && ctx.request.clientType > 1) {
+          throw new Error('没有权限')
+        }
+
+        const hooksList = ['beforeValidate', 'validate', 'afterValidate']
+        for (let i = 0; i < hooksList.length; i++) {
+          if (_.get(app, `${appName}.${hooksList[i]}.${controller}.${fn}`)) {
+            await app[appName][hooksList[i]][controller][fn](ctx)
+          }
+        }
+        if (['findOne', 'findAll', 'findAndCountAll', 'count'].includes(fn)) {
+          const {
+            where,
+            limit,
+            offset,
+            includes,
+            order,
+            union,
+            include,
+            referenceInclude,
+            relate,
+            attributes,
+            excludeInclude,
+            raw = false,
+            is_split = false,
+            omit = [],
+            ...other
+          } = ctx.request.body
+          if (['findOne', 'findAll', 'findAndCountAll'].includes(fn)) {
+            if (!_.isEmpty(other)) {
+              throw new Error('参数不合理，条件需要放在where里')
+            }
+          }
+
+          let myInclude
+          if (include) {
+            if (relate) {
+              /**
+               * 如果像user_distribute里有两个user，需要用这个来重新建立关系
+               */
+              const _str = formatPostFunction(relate)
+              nodeVm.runInNewContext(_str)(app[appName])
+              // relate.toFunction()(app[appName]);
+            }
+            const _str = formatPostFunction(include)
+            const postInclude = nodeVm.runInNewContext(_str)
+            // const postInclude = include.toFunction();
+            myInclude =
+              app[appName] &&
+              app[appName].include &&
+              app[appName].include[controller]
+                ? _.uniqWith(
+                    [
+                      ...postInclude(app[appName]),
+                      ...app[appName].include[controller],
+                    ],
+                    _.isEqual
+                  )
+                : postInclude(app[appName])
+          } else if (include === null) {
+            myInclude = null
+          } else {
+            myInclude = app[appName].include
+              ? app[appName].include[controller]
+              : null
+          }
+
+          if (referenceInclude) {
+            const _referenceInclude = Object.keys(referenceInclude).map(
+              (model) => ({
+                model: app[appName].model[model],
+                where: {
+                  ...referenceInclude[model],
+                },
+              })
+            )
+            myInclude = [...myInclude, ..._referenceInclude]
+          }
+          myInclude = myInclude.filter(
+            (item) => item.model && item.model.getName()
+          )
+
+          if (
+            excludeInclude &&
+            Array.isArray(excludeInclude) &&
+            excludeInclude.length > 0
+          ) {
+            myInclude = myInclude.filter((i) => {
+              return excludeInclude.every((m) => {
+                return app[appName].model[m] !== i.model
+              })
+            })
+          }
+
+          let _where
+
+          if (where) {
+            _where = _.cloneDeep(where)
+            // if (util.isObject(where)) {
+            //   _where = _.cloneDeep(where);
+            // } else if (util.isString(where)) {
+            //   const _fn = app[appName].vm.run(where);
+            //   _where = _fn(Sequelize.Op);
+            //   // _where = where.toFunction()(Sequelize.Op);
+            // }
+          } else {
+            _where = {}
+          }
+          if (fn === 'count') {
+            const requiredInclude = myInclude.filter(
+              (item) =>
+                (item.where && !item.hasOwnProperty('required')) ||
+                (item.hasOwnProperty('required') && item.required)
+            )
+            const result = await app[appName].model[controller][fn]({
+              where: _where,
+              include: requiredInclude,
+              attributes,
+              group: other.group,
+            })
+            ctx.SUCCESS(result)
+          }
+          if (['findOne', 'findAll', 'findAndCountAll'].includes(fn)) {
+            // 拆分
+            if (is_split) {
+              if (fn === 'findAndCountAll') {
+                const requiredInclude = myInclude.filter(
+                  (item) =>
+                    (item.where && !item.hasOwnProperty('required')) ||
+                    (item.hasOwnProperty('required') && item.required)
+                )
+                const { count, rows } = await app[appName].model[controller][
+                  fn
+                ]({
+                  where: _where,
+                  limit,
+                  offset,
+                  includes,
+                  include: requiredInclude,
+                  order,
+                  distinct: true,
+                  attributes,
+                  raw,
+                })
+                if (rows.length === 0) {
+                  return ctx.SUCCESS({
+                    count,
+                    rows: [],
+                  })
+                }
+
+                let objList = {}
+                for (let j = 0; j < myInclude.length; j++) {
+                  if (
+                    (myInclude[j].where &&
+                      !myInclude[j].hasOwnProperty('required')) ||
+                    (myInclude[j].hasOwnProperty('required') &&
+                      myInclude[j].required)
+                  ) {
+                    continue
+                  }
+                  const model = myInclude[j].model
+                  const modelName = model.getName()
+
+                  if (app[appName].attributes[controller][modelName + '_id']) {
+                    const idList = rows
+                      .map((r) => r[modelName + '_id'])
+                      .filter((item) => item)
+
+                    if (idList.length) {
+                      const list =
+                        !myInclude[j].include &&
+                        app[appName].cache.get(modelName)
+                          ? app[appName].cache.get(modelName)
+                          : await model.findAll({
+                              where: {
+                                id: idList,
+                                ...myInclude[j].where,
+                              },
+                              include: myInclude[j].include,
+                            })
+                      objList = {
+                        ...objList,
+                        [modelName]: list,
+                      }
+                    } else {
+                      objList = {
+                        ...objList,
+                        [modelName]: [],
+                      }
+                    }
+                  } else {
+                    const idList = rows.map((r) => r.id).filter((item) => item)
+                    if (idList.length) {
+                      const list = await model.findAll({
+                        where: {
+                          [controller + '_id']: idList,
+                          ...myInclude[j].where,
+                        },
+                        include: myInclude[j].include,
+                      })
+                      objList = {
+                        ...objList,
+                        [modelName]: list,
+                      }
+                    } else {
+                      objList = {
+                        ...objList,
+                        [modelName]: [],
+                      }
+                    }
+                  }
+                }
+
+                let result = []
+                for (let i = 0; i < rows.length; i++) {
+                  for (let j = 0; j < myInclude.length; j++) {
+                    if (
+                      (myInclude[j].where &&
+                        !myInclude[j].hasOwnProperty('required')) ||
+                      (myInclude[j].hasOwnProperty('required') &&
+                        myInclude[j].required)
+                    ) {
+                      continue
+                    }
+                    const model = myInclude[j].model
+                    const modelName = model.getName()
+                    if (
+                      app[appName].attributes[controller][modelName + '_id']
+                    ) {
+                      const target = objList[modelName].find(
+                        (b) => b.id === rows[i][modelName + '_id']
+                      )
+                      rows[i].setDataValue(modelName, target)
+                    } else {
+                      const hasOne =
+                        app[appName].attributes[modelName][controller + '_id']
+                          .hasOne
+                      if (hasOne) {
+                        rows[i].setDataValue(
+                          modelName,
+                          objList[modelName].find(
+                            (b) => b[controller + '_id'] === rows[i].id
+                          ) || null
+                        )
+                      } else {
+                        rows[i].setDataValue(
+                          [modelName + 's'],
+                          objList[modelName].filter(
+                            (b) => b[controller + '_id'] === rows[i].id
+                          )
+                        )
+                      }
+                    }
+                  }
+                  result = [...result, rows[i]]
+                }
+                ctx.SUCCESS({ count, rows: result })
+              } else if (fn === 'findAll') {
+                const requiredInclude = myInclude.filter(
+                  (item) =>
+                    (item.where && !item.hasOwnProperty('required')) ||
+                    (item.hasOwnProperty('required') && item.required)
+                )
+                const rows = await app[appName].model[controller][fn]({
+                  where: _where,
+                  limit,
+                  offset,
+                  includes,
+                  include: requiredInclude,
+                  order,
+                  distinct: true,
+                  attributes,
+                  raw,
+                })
+
+                if (rows.length === 0) ctx.SUCCESS([])
+                let objList = {}
+                for (let j = 0; j < myInclude.length; j++) {
+                  const model = myInclude[j].model
+                  const modelName = model.getName()
+
+                  if (app[appName].attributes[controller][modelName + '_id']) {
+                    const modelIdList = _.uniq(
+                      rows
+                        .reduce((a, b) => {
+                          const next = Array.isArray(b[modelName + '_id'])
+                            ? b[modelName + '_id']
+                            : [b[modelName + '_id']]
+                          return [...a, ...next]
+                        }, [])
+                        .filter((item) => item)
+                    )
+                    if (modelIdList.length) {
+                      const list =
+                        !myInclude[j].include &&
+                        !myInclude[j].where &&
+                        app[appName].cache.get(modelName)
+                          ? app[appName].cache.get(modelName)
+                          : await model.findAll({
+                              where: {
+                                id: modelIdList,
+                                ...(myInclude[j].where
+                                  ? myInclude[j].where
+                                  : {}),
+                              },
+                              include: myInclude[j].include,
+                            })
+                      objList = {
+                        ...objList,
+                        [modelName]: list,
+                      }
+                    } else {
+                      objList = {
+                        ...objList,
+                        [modelName]: [],
+                      }
+                    }
+                  } else {
+                    const modelIdList = rows
+                      .map((r) => r.id)
+                      .filter((item) => item)
+                    if (
+                      modelIdList.length &&
+                      app[appName].attributes[modelName] &&
+                      app[appName].attributes[modelName][controller + '_id']
+                    ) {
+                      const { required, include, where, ...rest } = myInclude[j]
+                      const list = await model.findAll({
+                        where: {
+                          [controller + '_id']: modelIdList,
+                          ...(where || {}),
+                        },
+                        ...rest,
+                        include,
+                      })
+                      objList = {
+                        ...objList,
+                        [modelName]: list,
+                      }
+                    } else {
+                      objList = {
+                        ...objList,
+                        [modelName]: [],
+                      }
+                    }
+                  }
+                }
+
+                let result = []
+                for (let i = 0; i < rows.length; i++) {
+                  for (let j = 0; j < myInclude.length; j++) {
+                    const model = myInclude[j].model
+                    const modelName = model.getName()
+                    if (
+                      app[appName].attributes[controller][modelName + '_id']
+                    ) {
+                      const is_single = !(
+                        (app[appName].attributes[controller][modelName + '_id']
+                          .defaultValue &&
+                          Array.isArray(
+                            app[appName].attributes[controller][
+                              modelName + '_id'
+                            ].defaultValue
+                          )) ||
+                        (app[appName].attributes[controller][modelName + '_id']
+                          .type &&
+                          app[appName].attributes[controller][modelName + '_id']
+                            .type === 'JSON') ||
+                        (app[appName].attributes[controller][modelName + '_id']
+                          .type &&
+                          app[appName].attributes[controller][modelName + '_id']
+                            .type.key &&
+                          app[appName].attributes[controller][modelName + '_id']
+                            .type.key === 'JSON')
+                      )
+                      if (is_single) {
+                        rows[i].setDataValue(
+                          modelName,
+                          objList[modelName].find(
+                            (b) => b.id === rows[i][modelName + '_id']
+                          )
+                        )
+                      } else {
+                        if (rows[i][modelName + '_id']) {
+                          rows[i].setDataValue(
+                            [modelName + 's'],
+                            rows[i][modelName + '_id'].map((modelId) => {
+                              return objList[modelName].find(
+                                (b) => b.id === modelId
+                              )
+                            })
+                          )
+                        }
+                      }
+                    } else {
+                      const hasOne =
+                        app[appName].attributes[modelName][
+                          controller + '_id'
+                        ] &&
+                        app[appName].attributes[modelName][controller + '_id']
+                          .hasOne
+
+                      if (hasOne) {
+                        rows[i].setDataValue(
+                          modelName,
+                          objList[modelName].find(
+                            (b) => b[controller + '_id'] === rows[i].id
+                          ) || null
+                        )
+                      } else {
+                        rows[i].setDataValue(
+                          [modelName + 's'],
+                          objList[modelName].filter(
+                            (b) => b[controller + '_id'] === rows[i].id
+                          )
+                        )
+                      }
+                    }
+                  }
+                  result = [...result, rows[i]]
+                }
+                ctx.SUCCESS(result)
+              } else if (fn === 'findOne') {
+                const target = await app[appName].model[controller][fn]({
+                  where: _where,
+                  limit,
+                  offset,
+                  includes,
+                  order,
+                  distinct: true,
+                  attributes,
+                  raw,
+                })
+
+                if (target === null) {
+                  return ctx.SUCCESS(null)
+                } else {
+                  let objList = {}
+                  for (let j = 0; j < myInclude.length; j++) {
+                    const model = myInclude[j].model
+                    const modelName = model.getName()
+                    if (
+                      app[appName].attributes[controller][modelName + '_id']
+                    ) {
+                      const modelIdList = _.uniq(
+                        [target]
+                          .reduce((a, b) => {
+                            const next = Array.isArray(b[modelName + '_id'])
+                              ? b[modelName + '_id']
+                              : [b[modelName + '_id']]
+                            return [...a, ...next]
+                          }, [])
+                          .filter((item) => item)
+                      )
+                      if (modelIdList.length) {
+                        const list =
+                          !myInclude[j].include &&
+                          !myInclude[j].where &&
+                          app[appName].cache.get(modelName)
+                            ? app[appName].cache.get(modelName)
+                            : await model.findAll({
+                                where: {
+                                  id: modelIdList,
+                                  ...(myInclude[j].where
+                                    ? myInclude[j].where
+                                    : {}),
+                                },
+                                include: myInclude[j].include,
+                              })
+                        objList = {
+                          ...objList,
+                          [modelName]: list,
+                        }
+                      } else {
+                        objList = {
+                          ...objList,
+                          [modelName]: [],
+                        }
+                      }
+                    } else {
+                      if (
+                        target.id &&
+                        app[appName].attributes[modelName] &&
+                        app[appName].attributes[modelName][controller + '_id']
+                      ) {
+                        const { required, include, where, ...rest } = myInclude[
+                          j
+                        ]
+                        const list = await model.findAll({
+                          where: {
+                            [controller + '_id']: target.id,
+                            ...(where || {}),
+                          },
+                          ...rest,
+                          include,
+                        })
+                        objList = {
+                          ...objList,
+                          [modelName]: list,
+                        }
+                      } else {
+                        objList = {
+                          ...objList,
+                          [modelName]: [],
+                        }
+                      }
+                    }
+                  }
+
+                  for (let j = 0; j < myInclude.length; j++) {
+                    const model = myInclude[j].model
+                    const modelName = model.getName()
+                    if (
+                      app[appName].attributes[controller][modelName + '_id']
+                    ) {
+                      const is_single = !(
+                        (app[appName].attributes[controller][modelName + '_id']
+                          .defaultValue &&
+                          Array.isArray(
+                            app[appName].attributes[controller][
+                              modelName + '_id'
+                            ].defaultValue
+                          )) ||
+                        (app[appName].attributes[controller][modelName + '_id']
+                          .type &&
+                          app[appName].attributes[controller][modelName + '_id']
+                            .type === 'JSON') ||
+                        (app[appName].attributes[controller][modelName + '_id']
+                          .type &&
+                          app[appName].attributes[controller][modelName + '_id']
+                            .type.key &&
+                          app[appName].attributes[controller][modelName + '_id']
+                            .type.key === 'JSON')
+                      )
+
+                      if (is_single) {
+                        target.setDataValue(
+                          modelName,
+                          objList[modelName].find(
+                            (b) => b.id === target[modelName + '_id']
+                          )
+                        )
+                      } else {
+                        if (target[modelName + '_id']) {
+                          target.setDataValue(
+                            [modelName + 's'],
+                            target[modelName + '_id'].map((modelId) => {
+                              return objList[modelName].find(
+                                (b) => b.id === modelId
+                              )
+                            })
+                          )
+                        }
+                      }
+                    } else {
+                      const hasOne =
+                        app[appName].attributes[modelName][
+                          controller + '_id'
+                        ] &&
+                        app[appName].attributes[modelName][controller + '_id']
+                          .hasOne
+
+                      if (hasOne) {
+                        target.setDataValue(
+                          modelName,
+                          objList[modelName].find(
+                            (b) => b[controller + '_id'] === target.id
+                          ) || null
+                        )
+                      } else {
+                        target.setDataValue(
+                          [modelName + 's'],
+                          objList[modelName].filter(
+                            (b) => b[controller + '_id'] === target.id
+                          )
+                        )
+                      }
+                    }
+                  }
+
+                  ctx.SUCCESS(target)
+                }
+              }
+            } else {
+              let needInclude = []
+              let specialInclude = []
+              for (let i = 0; i < myInclude.length; i++) {
+                const model = myInclude[i].model
+                const modelName = model.getName()
+
+                const is_single = !(
+                  (app[appName].attributes[controller][modelName + '_id'] &&
+                    app[appName].attributes[controller][modelName + '_id']
+                      .defaultValue &&
+                    Array.isArray(
+                      app[appName].attributes[controller][modelName + '_id']
+                        .defaultValue
+                    )) ||
+                  (app[appName].attributes[controller][modelName + '_id'] &&
+                    app[appName].attributes[controller][modelName + '_id']
+                      .type &&
+                    app[appName].attributes[controller][modelName + '_id']
+                      .type === 'JSON') ||
+                  (app[appName].attributes[controller][modelName + '_id'] &&
+                    app[appName].attributes[controller][modelName + '_id']
+                      .type &&
+                    app[appName].attributes[controller][modelName + '_id'].type
+                      .key &&
+                    app[appName].attributes[controller][modelName + '_id'].type
+                      .key === 'JSON')
+                )
+
+                if (is_single) {
+                  needInclude = [...needInclude, myInclude[i]]
+                } else {
+                  specialInclude = [...specialInclude, myInclude[i]]
+                }
+              }
+
+              if (specialInclude.length === 0) {
+                const result = await app[appName].model[controller][fn]({
+                  where: _where,
+                  limit,
+                  offset,
+                  includes,
+                  order,
+                  distinct: true,
+                  include: needInclude,
+                  attributes,
+                  raw,
+                })
+                if (omit.length === 0) {
+                  ctx.SUCCESS(result)
+                } else {
+                  ctx.SUCCESS(
+                    result.map((target) => {
+                      return _.omit(target.toJSON(), omit)
+                    })
+                  )
+                }
+              } else {
+                const rows = await app[appName].model[controller][fn]({
+                  where: _where,
+                  limit,
+                  offset,
+                  includes,
+                  order,
+                  distinct: true,
+                  include: needInclude,
+                  attributes,
+                  raw,
+                })
+                if (fn === 'findAndCountAll') {
+                  ctx.SUCCESS(rows)
+                } else if (fn === 'findAll') {
+                  if (rows.length === 0) ctx.SUCCESS([])
+                  let objList = {}
+                  for (let j = 0; j < specialInclude.length; j++) {
+                    const model = specialInclude[j].model
+                    const modelName = model.getName()
+                    const modelIdList = _.uniq(
+                      rows
+                        .reduce((a, b) => {
+                          const next = Array.isArray(b[modelName + '_id'])
+                            ? b[modelName + '_id']
+                            : [b[modelName + '_id']]
+                          return [...a, ...next]
+                        }, [])
+                        .filter((item) => item)
+                    )
+                    if (modelIdList.length) {
+                      const list = await model.findAll({
+                        where: {
+                          id: modelIdList,
+                        },
+                      })
+                      objList = {
+                        ...objList,
+                        [modelName]: list,
+                      }
+                    } else {
+                      objList = {
+                        ...objList,
+                        [modelName]: [],
+                      }
+                    }
+                  }
+
+                  let result = []
+                  for (let i = 0; i < rows.length; i++) {
+                    for (let j = 0; j < specialInclude.length; j++) {
+                      const model = specialInclude[j].model
+
+                      const modelName = model.getName()
+
+                      if (rows[i][modelName + '_id']) {
+                        rows[i].setDataValue(
+                          modelName + 's',
+                          rows[i][modelName + '_id'] === null
+                            ? []
+                            : rows[i][modelName + '_id']
+                                .map((modelId) => {
+                                  return objList[modelName].find(
+                                    (b) => b.id === modelId
+                                  )
+                                })
+                                .filter((item) => item)
+                        )
+                      }
+                    }
+
+                    result = [
+                      ...result,
+                      omit.length === 0
+                        ? rows[i]
+                        : _.omit(rows[i].toJSON(), omit),
+                    ]
+                  }
+                  ctx.SUCCESS(result)
+                } else {
+                  if (rows == null) return ctx.SUCCESS(null)
+                  let objList = {}
+                  for (let j = 0; j < specialInclude.length; j++) {
+                    const model = specialInclude[j].model
+                    const modelName = model.getName()
+                    const modelIdList = _.uniq(
+                      [rows]
+                        .reduce((a, b) => {
+                          const next = Array.isArray(b[modelName + '_id'])
+                            ? b[modelName + '_id']
+                            : [b[modelName + '_id']]
+                          return [...a, ...next]
+                        }, [])
+                        .filter((item) => item)
+                    )
+                    if (modelIdList.length) {
+                      const list = await model.findAll({
+                        where: {
+                          id: modelIdList,
+                        },
+                      })
+                      objList = {
+                        ...objList,
+                        [modelName]: list,
+                      }
+                    } else {
+                      objList = {
+                        ...objList,
+                        [modelName]: [],
+                      }
+                    }
+                  }
+                  for (let j = 0; j < specialInclude.length; j++) {
+                    const model = specialInclude[j].model
+                    const modelName = model.getName()
+
+                    if (rows[modelName + '_id']) {
+                      rows.setDataValue(
+                        modelName + 's',
+                        rows[modelName + '_id'] === null
+                          ? []
+                          : rows[modelName + '_id']
+                              .map((modelId) => {
+                                return objList[modelName].find(
+                                  (b) => b.id === modelId
+                                )
+                              })
+                              .filter((item) => item)
+                      )
+                    }
+                  }
+
+                  ctx.SUCCESS(omit.length === 0 ? rows : _.omit(rows, omit))
+                }
+              }
+            }
+          }
+        }
+
+        if (fn === 'bulkCreate') {
+          const { list, key = [] } = ctx.request.body
+          if (!list || !key) throw new Error('缺少list/key')
+          if (key.length) {
+            const result = await app[appName].model[controller][fn](list, {
+              updateOnDuplicate: key,
+            })
+            ctx.SUCCESS(result)
+          } else {
+            const result = await app[appName].model[controller][fn](list)
+            ctx.SUCCESS(result)
+          }
+        }
+
+        if (fn === 'upsert' || fn === 'create') {
+          if (_.isEmpty(ctx.request.body)) {
+            throw new Error('新增不能为空')
+          }
+          const _exclude =
+            ctx.request[`${appName}-user`] &&
+            ctx.request[`${appName}-user`].name &&
+            ctx.request[`${appName}-user`].name === 'admin'
+              ? ['updated_at']
+              : ['created_at', 'updated_at']
+          const newData = _.omit(_.omitBy(ctx.request.body, _.isNull), _exclude)
+
+          const flag = await app[appName].model[controller][fn]({
+            createdid: ctx.request[`${appName}-user`]
+              ? ctx.request[`${appName}-user`].id
+              : 0,
+            ...newData,
+          })
+          ctx.SUCCESS(flag)
+
+          if (cacheModel.includes(controller)) {
+            ctx.app[appName].cache.set(`${controller}`, null)
+          }
+        }
+
+        if (fn === 'destroy') {
+          if (_.isEmpty(ctx.request.body)) throw new Error('请输入删除条件')
+          const where =
+            ctx.request.clientType > 1
+              ? {
+                  ...ctx.request.body,
+                  createdid:
+                    ctx.request.clientType > 1
+                      ? ctx.request[`${appName}-user`]
+                        ? ctx.request[`${appName}-user`].id
+                        : 0
+                      : 0,
+                }
+              : ctx.request.body
+          const result = await app[appName].model[controller][fn]({
+            where,
+          })
+          if (result === 0) throw new Error('删除失败')
+          ctx.SUCCESS(result)
+
+          if (cacheModel.includes(controller)) {
+            ctx.app[appName].cache.set(`${controller}`, null)
+          }
+        }
+
+        if (_.get(app, `${appName}.afterExecute.${controller}.${fn}`)) {
+          app[appName].afterExecute[controller][fn](ctx)
+            .then((res) => {
+              console.log('afterUpdate', res)
+            })
+            .catch((e) => {
+              console.log('错误', e)
+              const errorData = {
+                url: ctx.request.href,
+                body: ctx.request.body,
+                message: e.message,
+                content: e.stack,
+                header: ctx.request.header,
+              }
+              if (
+                app[appName] &&
+                app[appName].model &&
+                app[appName].model.log
+              ) {
+                app[appName].model.log.upsert(errorData)
+              }
+            })
+        }
+      }
+    })
+  }
+}
+
+APP.Sequelize = Sequelize
+APP.lodash = _
+APP.Random = Random
+APP.Validator = Validator
+APP.moment = moment
+global.moment = moment
+global.Sequelize = Sequelize
+global.lodash = _
+APP.getService = (name) => {
+  const target = require(path.resolve(__dirname, `./file/services/${name}`))
+  return target
+}
+APP.getAppByCtx = (ctx) => {
+  const appName = ctx.router.opts.prefix.substring(1)
+
+  let controller = ''
+  try {
+    const url = ctx.request.url
+    const _split = url.split('/')
+    controller = _split[2]
+  } catch (e) {
+    console.warn(e)
+  }
+  const { [appName]: app } = ctx.app
+  return {
+    appName,
+    app,
+    controller,
+  }
+}
+
+APP.getClientTypeByCtx = (ctx) => {
+  const typeEnum = {
+    1: 'admin',
+    2: 'h5',
+    3: 'mp',
+    4: 'toutiao',
+    5: 'alipay',
+  }
+  if (ctx && ctx.request && ctx.request.clientType) {
+    const type = ctx.request.clientType
+    if (typeEnum[type]) {
+      return typeEnum[type]
+    }
+    return null
+  }
+  return null
+}
+
+APP.getConfig = (app) => ({
+  async getObject(type) {
+    let configList = await app.cache.get('configList')
+    if (!configList) {
+      configList = await app.model.setting.findAll({
+        raw: true,
+        where: {
+          is_cache: true,
+        },
+        attributes: {
+          exclude: [
+            'name',
+            'created_at',
+            'updated_at',
+            'is_cache',
+            'is_front',
+            'is_control',
+            'createdid',
+          ],
+        },
+        include: [
+          {
+            model: app.model.setting,
+            as: 'parent',
+            attributes: {
+              exclude: [
+                'name',
+                'type',
+                'value',
+                'created_at',
+                'updated_at',
+                'is_cache',
+                'is_front',
+                'is_control',
+                'createdid',
+              ],
+            },
+          },
+        ],
+      })
+      await app.cache.set(
+        'configList',
+        configList.map((item) => ({
+          ...item,
+        }))
+      )
+
+      const result = getObject(configList)(type)
+      if (!result) throw new Error('没有这个type')
+      return result
+    }
+    const result = getObject(configList)(type)
+    if (!result) throw new Error('没有这个type')
+    return result
+  },
+  update() {
+    app.cache.set('configList', null)
+  },
+})
+
+module.exports = APP