@waline/vercel 1.30.4 → 1.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waline/vercel",
-  "version": "1.30.4",
+  "version": "1.31.0",
   "description": "vercel server for waline comment system",
   "keywords": [
     "waline",
@@ -19,21 +19,22 @@
     "@koa/cors": "^4.0.0",
     "akismet": "^2.0.7",
     "deta": "^1.1.0",
-    "dompurify": "^3.0.2",
+    "dompurify": "^3.0.3",
     "dy-node-ip2region": "^1.0.1",
     "fast-csv": "^4.3.6",
     "form-data": "^4.0.0",
-    "jsdom": "^21.1.1",
+    "jsdom": "^22.1.0",
     "jsonwebtoken": "^9.0.0",
-    "katex": "^0.16.6",
+    "katex": "^0.16.7",
+    "koa-compose": "^4.1.0",
     "leancloud-storage": "^4.15.0",
     "markdown-it": "^13.0.1",
     "markdown-it-emoji": "^2.0.2",
     "markdown-it-sub": "^1.0.0",
     "markdown-it-sup": "^1.0.0",
     "mathjax-full": "^3.2.2",
-    "node-fetch": "^2.6.9",
-    "nodemailer": "^6.9.1",
+    "node-fetch": "^2.6.11",
+    "nodemailer": "^6.9.2",
     "nunjucks": "^3.2.4",
     "phpass": "^0.1.1",
     "prismjs": "^1.29.0",

package/src/config/config.js

@@ -45,6 +45,7 @@ const {
   LARK_TEMPLATE,
 
   LEVELS,
+  COMMENT_AUDIT,
 } = process.env;
 
 let storage = 'leancloud';
@@ -121,6 +122,8 @@ module.exports = {
     !LEVELS || isFalse(LEVELS)
       ? false
       : LEVELS.split(/\s*,\s*/).map((v) => Number(v)),
+
+  audit: !isFalse(COMMENT_AUDIT),
   avatarProxy,
   oauthUrl,
   markdown,

package/src/config/middleware.js

@@ -71,5 +71,8 @@ module.exports = [
   { handle: routerREST },
 
   'logic',
+  {
+    handle: 'plugin',
+  },
   'controller',
 ];

package/src/controller/comment.js

@@ -80,399 +80,17 @@ module.exports = class extends BaseRest {
 
   async getAction() {
     const { type } = this.get();
-    const { userInfo } = this.ctx.state;
-
-    switch (type) {
-      case 'recent': {
-        const { count } = this.get();
-        const where = {};
-
-        if (think.isEmpty(userInfo) || this.config('storage') === 'deta') {
-          where.status = ['NOT IN', ['waiting', 'spam']];
-        } else {
-          where._complex = {
-            _logic: 'or',
-            status: ['NOT IN', ['waiting', 'spam']],
-            user_id: userInfo.objectId,
-          };
-        }
-
-        const comments = await this.modelInstance.select(where, {
-          desc: 'insertedAt',
-          limit: count,
-          field: [
-            'status',
-            'comment',
-            'insertedAt',
-            'link',
-            'mail',
-            'nick',
-            'url',
-            'pid',
-            'rid',
-            'ua',
-            'ip',
-            'user_id',
-            'sticky',
-            'like',
-          ],
-        });
-
-        const userModel = this.getModel('Users');
-        const user_ids = Array.from(
-          new Set(comments.map(({ user_id }) => user_id).filter((v) => v))
-        );
-
-        let users = [];
-
-        if (user_ids.length) {
-          users = await userModel.select(
-            { objectId: ['IN', user_ids] },
-            {
-              field: [
-                'display_name',
-                'email',
-                'url',
-                'type',
-                'avatar',
-                'label',
-              ],
-            }
-          );
-        }
-
-        return this.jsonOrSuccess(
-          await Promise.all(
-            comments.map((cmt) =>
-              formatCmt(
-                cmt,
-                users,
-                { ...this.config(), deprecated: this.ctx.state.deprecated },
-                userInfo
-              )
-            )
-          )
-        );
-      }
-
-      case 'count': {
-        const { url } = this.get();
-        const where =
-          Array.isArray(url) && url.length ? { url: ['IN', url] } : {};
-
-        if (think.isEmpty(userInfo) || this.config('storage') === 'deta') {
-          where.status = ['NOT IN', ['waiting', 'spam']];
-        } else {
-          where._complex = {
-            _logic: 'or',
-            status: ['NOT IN', ['waiting', 'spam']],
-            user_id: userInfo.objectId,
-          };
-        }
-
-        if (
-          Array.isArray(url) &&
-          (url.length > 1 || !this.ctx.state.deprecated)
-        ) {
-          const data = await this.modelInstance.select(where, {
-            field: ['url'],
-          });
-
-          return this.jsonOrSuccess(
-            url.map((u) => data.filter(({ url }) => url === u).length)
-          );
-        }
-        const data = await this.modelInstance.count(where);
-
-        return this.jsonOrSuccess(data);
-      }
-
-      case 'list': {
-        const { page, pageSize, owner, status, keyword } = this.get();
-        const where = {};
-
-        if (owner === 'mine') {
-          const { userInfo } = this.ctx.state;
-
-          where.mail = userInfo.email;
-        }
-
-        if (status) {
-          where.status = status;
-
-          // compat with valine old data without status property
-          if (status === 'approved') {
-            where.status = ['NOT IN', ['waiting', 'spam']];
-          }
-        }
-
-        if (keyword) {
-          where.comment = ['LIKE', `%${keyword}%`];
-        }
-
-        const count = await this.modelInstance.count(where);
-        const spamCount = await this.modelInstance.count({ status: 'spam' });
-        const waitingCount = await this.modelInstance.count({
-          status: 'waiting',
-        });
-        const comments = await this.modelInstance.select(where, {
-          desc: 'insertedAt',
-          limit: pageSize,
-          offset: Math.max((page - 1) * pageSize, 0),
-        });
-
-        const userModel = this.getModel('Users');
-        const user_ids = Array.from(
-          new Set(comments.map(({ user_id }) => user_id).filter((v) => v))
-        );
-
-        let users = [];
-
-        if (user_ids.length) {
-          users = await userModel.select(
-            { objectId: ['IN', user_ids] },
-            {
-              field: [
-                'display_name',
-                'email',
-                'url',
-                'type',
-                'avatar',
-                'label',
-              ],
-            }
-          );
-        }
-
-        return this.success({
-          page,
-          totalPages: Math.ceil(count / pageSize),
-          pageSize,
-          spamCount,
-          waitingCount,
-          data: await Promise.all(
-            comments.map((cmt) =>
-              formatCmt(
-                cmt,
-                users,
-                { ...this.config(), deprecated: this.ctx.state.deprecated },
-                userInfo
-              )
-            )
-          ),
-        });
-      }
 
-      default: {
-        const { path: url, page, pageSize, sortBy } = this.get();
-        const where = { url };
-
-        if (think.isEmpty(userInfo) || this.config('storage') === 'deta') {
-          where.status = ['NOT IN', ['waiting', 'spam']];
-        } else if (userInfo.type !== 'administrator') {
-          where._complex = {
-            _logic: 'or',
-            status: ['NOT IN', ['waiting', 'spam']],
-            user_id: userInfo.objectId,
-          };
-        }
-
-        const totalCount = await this.modelInstance.count(where);
-        const pageOffset = Math.max((page - 1) * pageSize, 0);
-        let comments = [];
-        let rootComments = [];
-        let rootCount = 0;
-        const selectOptions = {
-          field: [
-            'status',
-            'comment',
-            'insertedAt',
-            'link',
-            'mail',
-            'nick',
-            'pid',
-            'rid',
-            'ua',
-            'ip',
-            'user_id',
-            'sticky',
-            'like',
-          ],
-        };
-
-        if (sortBy) {
-          const [field, order] = sortBy.split('_');
-
-          if (order === 'desc') {
-            selectOptions.desc = field;
-          } else if (order === 'asc') {
-            // do nothing because of ascending order is default behavior
-          }
-        }
-
-        /**
-         * most of case we have just little comments
-         * while if we want get rootComments, rootCount, childComments with pagination
-         * we have to query three times from storage service
-         * That's so expensive for user, especially in the serverless.
-         * so we have a comments length check
-         * If you have less than 1000 comments, then we'll get all comments one time
-         * then we'll compute rootComment, rootCount, childComments in program to reduce http request query
-         *
-         * Why we have limit and the limit is 1000?
-         * Many serverless storages have fetch data limit, for example LeanCloud is 100, and CloudBase is 1000
-         * If we have much comments, We should use more request to fetch all comments
-         * If we have 3000 comments, We have to use 30 http request to fetch comments, things go athwart.
-         * And Serverless Service like vercel have execute time limit
-         * if we have more http requests in a serverless function, it may timeout easily.
-         * so we use limit to avoid it.
-         */
-        if (totalCount < 1000) {
-          comments = await this.modelInstance.select(where, selectOptions);
-          rootCount = comments.filter(({ rid }) => !rid).length;
-          rootComments = [
-            ...comments.filter(({ rid, sticky }) => !rid && sticky),
-            ...comments.filter(({ rid, sticky }) => !rid && !sticky),
-          ].slice(pageOffset, pageOffset + pageSize);
-          const rootIds = {};
-
-          rootComments.forEach(({ objectId }) => {
-            rootIds[objectId] = true;
-          });
-          comments = comments.filter(
-            (cmt) => rootIds[cmt.objectId] || rootIds[cmt.rid]
-          );
-        } else {
-          comments = await this.modelInstance.select(
-            { ...where, rid: undefined },
-            { ...selectOptions }
-          );
-          rootCount = comments.length;
-          rootComments = [
-            ...comments.filter(({ rid, sticky }) => !rid && sticky),
-            ...comments.filter(({ rid, sticky }) => !rid && !sticky),
-          ].slice(pageOffset, pageOffset + pageSize);
-
-          const children = await this.modelInstance.select(
-            {
-              ...where,
-              rid: ['IN', rootComments.map(({ objectId }) => objectId)],
-            },
-            selectOptions
-          );
-
-          comments = [...rootComments, ...children];
-        }
-
-        const userModel = this.getModel('Users');
-        const user_ids = Array.from(
-          new Set(comments.map(({ user_id }) => user_id).filter((v) => v))
-        );
-        let users = [];
-
-        if (user_ids.length) {
-          users = await userModel.select(
-            { objectId: ['IN', user_ids] },
-            {
-              field: [
-                'display_name',
-                'email',
-                'url',
-                'type',
-                'avatar',
-                'label',
-              ],
-            }
-          );
-        }
-
-        if (think.isArray(this.config('levels'))) {
-          const countWhere = {
-            status: ['NOT IN', ['waiting', 'spam']],
-            _complex: {},
-          };
-
-          if (user_ids.length) {
-            countWhere._complex.user_id = ['IN', user_ids];
-          }
-          const mails = Array.from(
-            new Set(comments.map(({ mail }) => mail).filter((v) => v))
-          );
+    const fnMap = {
+      recent: this.getRecentCommentList,
+      count: this.getCommentCount,
+      list: this.getAdminCommentList,
+    };
 
-          if (mails.length) {
-            countWhere._complex.mail = ['IN', mails];
-          }
-          if (!think.isEmpty(countWhere._complex)) {
-            countWhere._complex._logic = 'or';
-          } else {
-            delete countWhere._complex;
-          }
-          const counts = await this.modelInstance.count(countWhere, {
-            group: ['user_id', 'mail'],
-          });
-
-          comments.forEach((cmt) => {
-            const countItem = (counts || []).find(({ mail, user_id }) => {
-              if (cmt.user_id) {
-                return user_id === cmt.user_id;
-              }
-
-              return mail === cmt.mail;
-            });
-
-            let level = 0;
-
-            if (countItem) {
-              const _level = think.findLastIndex(
-                this.config('levels'),
-                (l) => l <= countItem.count
-              );
-
-              if (_level !== -1) {
-                level = _level;
-              }
-            }
-            cmt.level = level;
-          });
-        }
+    const fn = fnMap[type] || this.getCommentList;
+    const data = await fn.call(this);
 
-        return this[this.ctx.state.deprecated ? 'json' : 'success']({
-          page,
-          totalPages: Math.ceil(rootCount / pageSize),
-          pageSize,
-          count: totalCount,
-          data: await Promise.all(
-            rootComments.map(async (comment) => {
-              const cmt = await formatCmt(
-                comment,
-                users,
-                { ...this.config(), deprecated: this.ctx.state.deprecated },
-                userInfo
-              );
-
-              cmt.children = await Promise.all(
-                comments
-                  .filter(({ rid }) => rid === cmt.objectId)
-                  .map((cmt) =>
-                    formatCmt(
-                      cmt,
-                      users,
-                      {
-                        ...this.config(),
-                        deprecated: this.ctx.state.deprecated,
-                      },
-                      userInfo
-                    )
-                  )
-                  .reverse()
-              );
-
-              return cmt;
-            })
-          ),
-        });
-      }
-    }
+    return this.jsonOrSuccess(data);
   }
 
   async postAction() {
@@ -553,9 +171,7 @@ module.exports = class extends BaseRest {
       think.logger.debug(`Comment post frequency check OK!`);
 
       /** Akismet */
-      const { COMMENT_AUDIT } = process.env;
-
-      data.status = COMMENT_AUDIT ? 'waiting' : 'approved';
+      data.status = this.config('audit') ? 'waiting' : 'approved';
 
       think.logger.debug(`Comment initial status is ${data.status}`);
 
@@ -766,4 +382,353 @@ module.exports = class extends BaseRest {
 
     return this.success();
   }
+
+  async getCommentList() {
+    const { userInfo } = this.ctx.state;
+    const { path: url, page, pageSize, sortBy } = this.get();
+    const where = { url };
+
+    if (think.isEmpty(userInfo) || this.config('storage') === 'deta') {
+      where.status = ['NOT IN', ['waiting', 'spam']];
+    } else if (userInfo.type !== 'administrator') {
+      where._complex = {
+        _logic: 'or',
+        status: ['NOT IN', ['waiting', 'spam']],
+        user_id: userInfo.objectId,
+      };
+    }
+
+    const totalCount = await this.modelInstance.count(where);
+    const pageOffset = Math.max((page - 1) * pageSize, 0);
+    let comments = [];
+    let rootComments = [];
+    let rootCount = 0;
+    const selectOptions = {
+      field: [
+        'status',
+        'comment',
+        'insertedAt',
+        'link',
+        'mail',
+        'nick',
+        'pid',
+        'rid',
+        'ua',
+        'ip',
+        'user_id',
+        'sticky',
+        'like',
+      ],
+    };
+
+    if (sortBy) {
+      const [field, order] = sortBy.split('_');
+
+      if (order === 'desc') {
+        selectOptions.desc = field;
+      } else if (order === 'asc') {
+        // do nothing because of ascending order is default behavior
+      }
+    }
+
+    /**
+     * most of case we have just little comments
+     * while if we want get rootComments, rootCount, childComments with pagination
+     * we have to query three times from storage service
+     * That's so expensive for user, especially in the serverless.
+     * so we have a comments length check
+     * If you have less than 1000 comments, then we'll get all comments one time
+     * then we'll compute rootComment, rootCount, childComments in program to reduce http request query
+     *
+     * Why we have limit and the limit is 1000?
+     * Many serverless storages have fetch data limit, for example LeanCloud is 100, and CloudBase is 1000
+     * If we have much comments, We should use more request to fetch all comments
+     * If we have 3000 comments, We have to use 30 http request to fetch comments, things go athwart.
+     * And Serverless Service like vercel have execute time limit
+     * if we have more http requests in a serverless function, it may timeout easily.
+     * so we use limit to avoid it.
+     */
+    if (totalCount < 1000) {
+      comments = await this.modelInstance.select(where, selectOptions);
+      rootCount = comments.filter(({ rid }) => !rid).length;
+      rootComments = [
+        ...comments.filter(({ rid, sticky }) => !rid && sticky),
+        ...comments.filter(({ rid, sticky }) => !rid && !sticky),
+      ].slice(pageOffset, pageOffset + pageSize);
+      const rootIds = {};
+
+      rootComments.forEach(({ objectId }) => {
+        rootIds[objectId] = true;
+      });
+      comments = comments.filter(
+        (cmt) => rootIds[cmt.objectId] || rootIds[cmt.rid]
+      );
+    } else {
+      comments = await this.modelInstance.select(
+        { ...where, rid: undefined },
+        { ...selectOptions }
+      );
+      rootCount = comments.length;
+      rootComments = [
+        ...comments.filter(({ rid, sticky }) => !rid && sticky),
+        ...comments.filter(({ rid, sticky }) => !rid && !sticky),
+      ].slice(pageOffset, pageOffset + pageSize);
+
+      const children = await this.modelInstance.select(
+        {
+          ...where,
+          rid: ['IN', rootComments.map(({ objectId }) => objectId)],
+        },
+        selectOptions
+      );
+
+      comments = [...rootComments, ...children];
+    }
+
+    const userModel = this.getModel('Users');
+    const user_ids = Array.from(
+      new Set(comments.map(({ user_id }) => user_id).filter((v) => v))
+    );
+    let users = [];
+
+    if (user_ids.length) {
+      users = await userModel.select(
+        { objectId: ['IN', user_ids] },
+        {
+          field: ['display_name', 'email', 'url', 'type', 'avatar', 'label'],
+        }
+      );
+    }
+
+    if (think.isArray(this.config('levels'))) {
+      const countWhere = {
+        status: ['NOT IN', ['waiting', 'spam']],
+        _complex: {},
+      };
+
+      if (user_ids.length) {
+        countWhere._complex.user_id = ['IN', user_ids];
+      }
+      const mails = Array.from(
+        new Set(comments.map(({ mail }) => mail).filter((v) => v))
+      );
+
+      if (mails.length) {
+        countWhere._complex.mail = ['IN', mails];
+      }
+      if (!think.isEmpty(countWhere._complex)) {
+        countWhere._complex._logic = 'or';
+      } else {
+        delete countWhere._complex;
+      }
+      const counts = await this.modelInstance.count(countWhere, {
+        group: ['user_id', 'mail'],
+      });
+
+      comments.forEach((cmt) => {
+        const countItem = (counts || []).find(({ mail, user_id }) =>
+          cmt.user_id ? user_id === cmt.user_id : mail === cmt.mail
+        );
+
+        cmt.level = think.getLevel(countItem?.count);
+      });
+    }
+
+    return {
+      page,
+      totalPages: Math.ceil(rootCount / pageSize),
+      pageSize,
+      count: totalCount,
+      data: await Promise.all(
+        rootComments.map(async (comment) => {
+          const cmt = await formatCmt(
+            comment,
+            users,
+            { ...this.config(), deprecated: this.ctx.state.deprecated },
+            userInfo
+          );
+
+          cmt.children = await Promise.all(
+            comments
+              .filter(({ rid }) => rid === cmt.objectId)
+              .map((cmt) =>
+                formatCmt(
+                  cmt,
+                  users,
+                  {
+                    ...this.config(),
+                    deprecated: this.ctx.state.deprecated,
+                  },
+                  userInfo
+                )
+              )
+              .reverse()
+          );
+
+          return cmt;
+        })
+      ),
+    };
+  }
+
+  async getAdminCommentList() {
+    const { userInfo } = this.ctx.state;
+    const { page, pageSize, owner, status, keyword } = this.get();
+    const where = {};
+
+    if (owner === 'mine') {
+      const { userInfo } = this.ctx.state;
+
+      where.mail = userInfo.email;
+    }
+
+    if (status) {
+      where.status = status;
+
+      // compat with valine old data without status property
+      if (status === 'approved') {
+        where.status = ['NOT IN', ['waiting', 'spam']];
+      }
+    }
+
+    if (keyword) {
+      where.comment = ['LIKE', `%${keyword}%`];
+    }
+
+    const count = await this.modelInstance.count(where);
+    const spamCount = await this.modelInstance.count({ status: 'spam' });
+    const waitingCount = await this.modelInstance.count({
+      status: 'waiting',
+    });
+    const comments = await this.modelInstance.select(where, {
+      desc: 'insertedAt',
+      limit: pageSize,
+      offset: Math.max((page - 1) * pageSize, 0),
+    });
+
+    const userModel = this.getModel('Users');
+    const user_ids = Array.from(
+      new Set(comments.map(({ user_id }) => user_id).filter((v) => v))
+    );
+
+    let users = [];
+
+    if (user_ids.length) {
+      users = await userModel.select(
+        { objectId: ['IN', user_ids] },
+        {
+          field: ['display_name', 'email', 'url', 'type', 'avatar', 'label'],
+        }
+      );
+    }
+
+    return {
+      page,
+      totalPages: Math.ceil(count / pageSize),
+      pageSize,
+      spamCount,
+      waitingCount,
+      data: await Promise.all(
+        comments.map((cmt) =>
+          formatCmt(
+            cmt,
+            users,
+            { ...this.config(), deprecated: this.ctx.state.deprecated },
+            userInfo
+          )
+        )
+      ),
+    };
+  }
+
+  async getRecentCommentList() {
+    const { count } = this.get();
+    const { userInfo } = this.ctx.state;
+    const where = {};
+
+    if (think.isEmpty(userInfo) || this.config('storage') === 'deta') {
+      where.status = ['NOT IN', ['waiting', 'spam']];
+    } else {
+      where._complex = {
+        _logic: 'or',
+        status: ['NOT IN', ['waiting', 'spam']],
+        user_id: userInfo.objectId,
+      };
+    }
+
+    const comments = await this.modelInstance.select(where, {
+      desc: 'insertedAt',
+      limit: count,
+      field: [
+        'status',
+        'comment',
+        'insertedAt',
+        'link',
+        'mail',
+        'nick',
+        'url',
+        'pid',
+        'rid',
+        'ua',
+        'ip',
+        'user_id',
+        'sticky',
+        'like',
+      ],
+    });
+
+    const userModel = this.getModel('Users');
+    const user_ids = Array.from(
+      new Set(comments.map(({ user_id }) => user_id).filter((v) => v))
+    );
+
+    let users = [];
+
+    if (user_ids.length) {
+      users = await userModel.select(
+        { objectId: ['IN', user_ids] },
+        {
+          field: ['display_name', 'email', 'url', 'type', 'avatar', 'label'],
+        }
+      );
+    }
+
+    return Promise.all(
+      comments.map((cmt) =>
+        formatCmt(
+          cmt,
+          users,
+          { ...this.config(), deprecated: this.ctx.state.deprecated },
+          userInfo
+        )
+      )
+    );
+  }
+
+  async getCommentCount() {
+    const { url } = this.get();
+    const { userInfo } = this.ctx.state;
+    const where = Array.isArray(url) && url.length ? { url: ['IN', url] } : {};
+
+    if (think.isEmpty(userInfo) || this.config('storage') === 'deta') {
+      where.status = ['NOT IN', ['waiting', 'spam']];
+    } else {
+      where._complex = {
+        _logic: 'or',
+        status: ['NOT IN', ['waiting', 'spam']],
+        user_id: userInfo.objectId,
+      };
+    }
+
+    if (Array.isArray(url) && (url.length > 1 || !this.ctx.state.deprecated)) {
+      const data = await this.modelInstance.select(where, {
+        field: ['url'],
+      });
+
+      return url.map((u) => data.filter(({ url }) => url === u).length);
+    }
+    const data = await this.modelInstance.count(where);
+
+    return data;
+  }
 };

package/src/controller/rest.js

@@ -48,12 +48,22 @@ module.exports = class extends think.Controller {
 
   async hook(name, ...args) {
     const fn = this.config(name);
+    const plugins = think.getPluginHook(name);
 
-    if (!think.isFunction(fn)) {
-      return;
+    if (think.isFunction(fn)) {
+      plugins.unshift(fn);
     }
 
-    return fn.call(this, ...args);
+    for(let i = 0; i < plugins.length; i++) {
+      if (!think.isFunction(plugins[i])) {
+        continue;
+      }
+      
+      const resp = await plugins[i].call(this, ...args);
+      if (resp) {
+        return resp;
+      }
+    }
   }
 
   __call() {}

package/src/extend/think.js

@@ -101,4 +101,58 @@ module.exports = {
 
     return ua;
   },
+  getLevel(val) {
+    const levels = this.config('levels');
+    const defaultLevel = 0;
+
+    if (!val) {
+      return defaultLevel;
+    }
+
+    const level = think.findLastIndex(levels, (l) => l <= val);
+
+    return level === -1 ? defaultLevel : level;
+  },
+  pluginMap(type, callback) {
+    const plugins = think.config('plugins');
+    const fns = [];
+
+    if (!think.isArray(plugins)) {
+      return fns;
+    }
+  
+
+    for (let i = 0; i < plugins.length; i++) {
+      const plugin = plugins[i];
+  
+      if (!plugin || !plugin[type]) {
+        continue;
+      }
+
+      const res = callback(plugin[type]);
+      if (!res) {
+        continue;
+      }
+
+      fns.push(res);
+    }
+
+    return fns;
+  },
+  getPluginMiddlewares() {
+    const middlewares = think.pluginMap('middlewares', (middleware) => {
+      if (think.isFunction(middleware)) {
+        return middleware;
+      }
+  
+      if (think.isArray(middleware)) {
+       return middleware.filter((m) => think.isFunction(m));
+      }
+    });
+    
+    return middlewares.flat();
+  },
+  getPluginHook(hookName) {
+    return think.pluginMap('hooks', (hook) => think.isFunction(hook[hookName]) ? hook[hookName] : undefined).filter(v => v);
+  }
 };

package/src/middleware/plugin.js

@@ -0,0 +1,12 @@
+const compose = require('koa-compose');
+
+module.exports = function() {
+  return (ctx, next) => {
+    const middlewares = think.getPluginMiddlewares();
+    if (!think.isArray(middlewares) || !middlewares.length) {
+      next();
+    }
+  
+    compose(middlewares)(ctx, next);
+  };
+}