q-koa 8.6.3 → 8.6.4

package/core/file/plugins/system/service.js

@@ -1,220 +1,255 @@
-const fs = require('fs')
-const path = require('path')
-const fsPromise = require('fs/promises')
-exports.loadModel = async ({ app, appName }) => {
-  const data = await fsPromise.readdir(
-    path.resolve(__dirname, `${process.cwd()}/app/${appName}/plugins`)
-  )
-
-  // const modelList = await app.model.model.findAll({ raw: true })
+const { getConfig, lodash } = require('q-koa')
+const formatPostFunction = (str) => `eval(${str})`
+const nodeVm = require('vm')
+const { is } = require('cheerio/lib/api/traversing')
 
-  await Promise.all(
-    ['model', 'model_attributes'].map((item) =>
-      app.model[item].sync({
-        force: true,
-      })
-    )
-  )
+exports.initData = async ({ includes, excludes, app, ctx }) => {
+  const appConfig = getConfig(app)
+  const { version: cacheVersion } = await appConfig.getObject('base')
+  const apiVersion = ctx.request.header.version
+  const config = ctx.request.header.config
 
-  const dataList = []
-  const result = data.filter(
-    (item) => !['model', 'model_attributes'].includes(item)
-  )
-  for (let i = 0; i < result.length; i++) {
-    const filePath = path.resolve(
-      __dirname,
-      `${process.cwd()}/app/${appName}/plugins/${result[i]}/model.js`
-    )
-    const configPath = path.resolve(
-      __dirname,
-      `${process.cwd()}/app/${appName}/plugins/${result[i]}/config.js`
-    )
-    const defaultFilePath = path.resolve(__dirname, `../${result[i]}/model.js`)
-    const defaultConfigPath = path.resolve(
-      __dirname,
-      `../${result[i]}/config.js`
-    )
-    const modelExist = fs.existsSync(filePath)
-    const defaultModelExist = fs.existsSync(defaultFilePath)
-    const configExist = fs.existsSync(configPath)
-    if (configExist) {
-      const config = (await fsPromise.readFile(configPath, 'utf-8'))
-        ? require(configPath)
-        : require(defaultConfigPath)
+  if (!(excludes instanceof Array)) {
+    excludes = [excludes]
+  }
+  const result = await Promise.all(
+    Object.keys(includes)
+      .filter((item) => excludes.includes(item) || excludes.length === 0)
+      .map((item) => {
+        const route = includes[item]
+        if (lodash.isObject(route)) {
+          const {
+            url,
+            data,
+            order,
+            limit,
+            include,
+            excludeInclude,
+            autoInclude = true,
+          } = route
+          const [model, fn] = url.split('/')
 
-      const modelFile =
-        defaultModelExist || modelExist
-          ? (await fsPromise.readFile(filePath, 'utf-8'))
-            ? await fsPromise.readFile(filePath, 'utf-8')
-            : await fsPromise.readFile(defaultFilePath, 'utf-8')
-          : null
+          let myInclude
 
-      const model = modelFile
-        ? (await fsPromise.readFile(filePath, 'utf-8'))
-          ? require(filePath)
-          : require(defaultFilePath)
-        : {}
-      const attributes = modelFile ? modelFile.match(/exports.(.*)=/g) : []
-      const types = modelFile ? modelFile.match(/Sequelize.(.*),\n/g) : {}
+          if (include) {
+            const _str = formatPostFunction(include)
+            const postInclude = nodeVm.runInNewContext(_str)
+            // const postInclude = include.toFunction();
+            myInclude =
+              app.include && app.include[model]
+                ? [
+                    ...postInclude(app),
+                    ...(autoInclude ? app.include[model] : []),
+                  ]
+                : postInclude(app)
+          } else {
+            myInclude = autoInclude ? app.include[model] : []
+          }
 
-      // const ori_target = modelList.find((m) => m.model === result[i])
-      // const id = ori_target ? ori_target.id : null
-      const id = i + 1
-      const obj = {
-        id,
-        model: result[i],
-        name: config.name,
-        belongs: config.belongs || 'page',
-        order: config.order,
-        multiple: config.multiple,
-        availableSort: config.availableSort,
-        limit: config.limit || 20,
-        select: config.select,
-        excludes: config.excludes,
-        initList: config.initList,
-        defaultOrder: config.defaultOrder,
-        excludeAuth: config.excludeAuth,
-        comment: config.comment,
-        reference: config.reference,
-        include: config.include,
-        sortOrder: config.sortOrder,
-        personal: config.personal,
-        autoData: config.autoData,
-        is_split: config.is_split,
-        is_split_count: config.is_split_count,
-        show_virtual: config.show_virtual,
-        modelQuery: config.modelQuery,
-        referenceSelect: config.referenceSelect,
-        editInline: config.editInline,
-        deleteCheckList: config.deleteCheckList,
-        bulkCreateList: config.bulkCreateList,
-        list: attributes.map((attr, index) => {
-          const name = attr.match(/exports.(.*)=/)[1].trim()
-          let defaultValue = ''
-          if (model[name] && model[name].hasOwnProperty('defaultValue')) {
-            if (
-              typeof model[name].defaultValue === 'boolean' &&
-              model[name].defaultValue === true
-            ) {
-              defaultValue = 'true'
-            }
-            if (
-              typeof model[name].defaultValue === 'boolean' &&
-              model[name].defaultValue === false
-            ) {
-              defaultValue = 'false'
-            }
-            if (typeof model[name].defaultValue === 'number') {
-              defaultValue = `${model[name].defaultValue}`
-            }
-            if (Array.isArray(model[name].defaultValue)) {
-              defaultValue = JSON.stringify(model[name].defaultValue)
-            }
-            if (
-              Object.prototype.toString.call(model[name].defaultValue) ===
-              '[object Object]'
-            ) {
-              defaultValue = '{}'
-            }
-            if (
-              typeof model[name].defaultValue === 'string' &&
-              model[name].defaultValue === ''
-            ) {
-              defaultValue = "''"
-            }
-            if (
-              typeof model[name].defaultValue === 'string' &&
-              model[name].defaultValue !== ''
-            ) {
-              defaultValue = `'${model[name].defaultValue}'`
-            }
-            if (
-              !model[name].defaultValue &&
-              typeof model[name].defaultValue !== 'undefined' &&
-              model[name].defaultValue != 0
-            ) {
-              defaultValue = 'null'
-            }
-            if (
-              types[index] &&
-              types[index].includes('DATE') &&
-              model[name].allowNull === true
-            ) {
-              defaultValue = 'null'
-            }
-          } else if (
-            model[name] &&
-            !model[name].hasOwnProperty('defaultValue')
+          if (
+            excludeInclude &&
+            Array.isArray(excludeInclude) &&
+            excludeInclude.length > 0
           ) {
-            defaultValue = "''"
+            myInclude = myInclude.filter((i) => {
+              if (excludeInclude.includes(model)) return false
+              if (excludeInclude.includes(i.as)) return false
+              return (
+                (excludeInclude.every((m) => {
+                  return app.model[m] !== i.model
+                }) ||
+                  i.as) &&
+                !(
+                  i.as &&
+                  data.attributes &&
+                  data.attributes.exclude &&
+                  data.attributes.exclude.includes(i.as + '_id')
+                )
+              )
+            })
           }
 
+          if (app.controller[model] && app.controller[model][fn]) {
+            return app.controller[model][fn](ctx, data).then((result) => {
+              if (!result && process.env.NODE_ENV !== 'production') {
+                console.log(`需要在控制器${fn}中返回`)
+              }
+              return {
+                [item]: result,
+              }
+            })
+          } else if (app.model[model]) {
+            if (app.model[model][fn]) {
+              if (
+                data &&
+                data.cache_level &&
+                data.cache_level === 2 &&
+                app.model.cache
+              ) {
+                return app.model.cache
+                  .findOne({
+                    where: {
+                      key: JSON.stringify({
+                        order,
+                        limit,
+                        include: myInclude,
+                        ...data,
+                      }),
+                    },
+                  })
+                  .then((res) => {
+                    if (res && res.result) {
+                      console.log(`${model}有cache`)
+                      return Promise.resolve({
+                        [item]: res.result,
+                      })
+                    } else {
+                      return app.model[model][fn]({
+                        order,
+                        limit,
+                        include: myInclude,
+                        ...data,
+                      }).then((result) => {
+                        const list =
+                          data && data.omit && Array.isArray(data.omit)
+                            ? result.map((obj) => {
+                                return lodash.omit(obj.toJSON(), data.omit)
+                              })
+                            : result
+                        if (
+                          data &&
+                          data.cache_level &&
+                          data.cache_level === 2 &&
+                          list.length > 0
+                        ) {
+                          app.model.cache &&
+                            app.model.cache.create({
+                              key: JSON.stringify({
+                                order,
+                                limit,
+                                include: myInclude,
+                                ...data,
+                              }),
+                              result: list,
+                            })
+                        }
+                        return {
+                          [item]: list,
+                        }
+                      })
+                    }
+                  })
+              } else {
+                return app.model[model][fn]({
+                  order,
+                  limit,
+                  include: myInclude,
+                  ...data,
+                }).then((result) => {
+                  const list =
+                    data && data.omit && Array.isArray(data.omit)
+                      ? result.map((obj) => {
+                          return lodash.omit(obj.toJSON(), data.omit)
+                        })
+                      : result
+                  if (
+                    data &&
+                    data.cache_level &&
+                    data.cache_level === 1 &&
+                    list.length > 0
+                  ) {
+                    app.model.cache &&
+                      app.model.cache.update(
+                        {
+                          result: list,
+                        },
+                        {
+                          where: {
+                            key: JSON.stringify({
+                              order,
+                              limit,
+                              include: myInclude,
+                              ...data,
+                            }),
+                          },
+                        }
+                      )
+                  }
+                  return {
+                    [item]: list,
+                  }
+                })
+              }
+            } else {
+              return Promise.resolve({
+                [item]: [],
+              })
+            }
+          } else {
+            return Promise.resolve({
+              [item]: [],
+            })
+          }
+        }
+        const [model, fn] = route.split('/')
+        if (app.cache && app.cache.get(`${model}`)) {
+          return Promise.resolve({
+            [item]: app.cache.get(`${model}`),
+          })
+        }
+        return app.model[model][fn]({
+          include: app.include[model],
+          ...(app.config[model] ? app.config[model].autoData : {}),
+        }).then((res) => {
+          app.cache && app.cache.set(`${model}`, res)
+          const cacheModel = lodash.get(app, 'appConfig.cacheModel', [])
+          app.appConfig.cacheModel = Array.from(new Set([...cacheModel, model]))
           return {
-            model_id: id || i + 1,
-            name,
-            type: types[index] ? types[index].replace(/,\n/, '') : '',
-            comment: model[name] ? model[name].comment : '',
-            is_mock:
-              model[name] && model[name].is_mock
-                ? model[name].is_mock
-                : !!(model[name] && model[name].mock),
-            allowNull:
-              model[name] && model[name].allowNull
-                ? model[name].allowNull
-                : false,
-            defaultValue,
-            sortOrder:
-              model[name] && model[name].sortOrder
-                ? Number(model[name].sortOrder)
-                : 1,
-            mock:
-              model[name] && model[name].mock
-                ? model[name].mock.toString()
-                : '',
-            set:
-              model[name] && model[name].set ? model[name].set.toString() : '',
-            get:
-              model[name] && model[name].get ? model[name].get.toString() : '',
-            belongsTo: model[name] ? model[name].belongsTo : '',
-            unique: !!(model[name] && model[name].hasOwnProperty('unique')),
-            hasOne: !!(model[name] && model[name].hasOwnProperty('hasOne')),
-            validate:
-              model[name] && model[name].validate
-                ? JSON.stringify(model[name].validate)
-                : null,
-            extra:
-              model[name] && model[name].extra
-                ? JSON.stringify(model[name].extra)
-                : null,
+            [item]: res,
           }
-        }),
+        })
+      })
+  )
+
+  const obj = result.reduce(
+    (a, b) => ({
+      ...a,
+      ...b,
+    }),
+    {}
+  )
+  if (obj.setting && apiVersion && cacheVersion) {
+    let target = null
+    if (config) {
+      const application = app.cache.get('application')
+      if (application) {
+        target = application.find((a) => a.config === config)
       }
-      // if (obj.model === 'user_free') {
-      //   console.log(obj)
-      // }
-      dataList.push(obj)
     }
-  }
 
-  const promise1 = app.model.model.bulkCreate(
-    dataList.map((item) => {
-      return {
-        ...item,
-        list: item.list.filter((t) => t.type),
-      }
-    })
-  )
-  const promise2 = app.model.model_attributes.bulkCreate(
-    dataList
-      .filter((item) => item.list.every((t) => t.type))
-      .reduce((a, b) => [...a, ...b.list], [])
-  )
+    return {
+      ...obj,
+      setting: obj.setting.map((i) => {
+        if (i.code === 'is_check' && i.value === false) {
+          return {
+            ...(i.toJSON ? i.toJSON() : i),
+            value: apiVersion === cacheVersion,
+          }
+        }
 
-  await Promise.all([promise1, promise2])
-  console.log('lodaModel success!')
-  if (app.service.routes && app.model.routes) {
-    await app.service.routes.initRouter({ app })
-  } else {
-    console.warn('routes可能没有service.js')
+        if (
+          target &&
+          target.hasOwnProperty(i.code) &&
+          i.hasOwnProperty('value')
+        ) {
+          return {
+            ...(i.toJSON ? i.toJSON() : i),
+            value: target[i.code],
+          }
+        }
+        return i
+      }),
+    }
   }
+  return obj
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "q-koa",
-  "version": "8.6.3",
+  "version": "8.6.4",
   "description": "",
   "main": "index.js",
   "scripts": {