@waline/vercel 1.14.0 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waline/vercel",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "vercel server for waline comment system",
   "keywords": [
     "waline",
@@ -42,7 +42,7 @@
     "think-model-mysql": "^1.1.7",
     "think-model-postgresql": "1.1.6",
     "think-model-sqlite": "^1.2.3",
-    "think-mongo": "^2.1.2",
+    "think-mongo": "^2.2.1",
     "think-router-rest": "^1.0.5",
     "thinkjs": "^3.2.14",
     "ua-parser-js": "^1.0.2"

package/src/config/config.js

@@ -37,6 +37,8 @@ const {
   TG_TEMPLATE,
   WX_TEMPLATE,
   DISCORD_TEMPLATE,
+
+  LEVELS,
 } = process.env;
 
 let storage = 'leancloud';
@@ -104,6 +106,9 @@ module.exports = {
   disallowIPList: [],
   secureDomains: SECURE_DOMAINS ? SECURE_DOMAINS.split(/\s*,\s*/) : undefined,
   disableUserAgent: DISABLE_USERAGENT && !isFalse(DISABLE_USERAGENT),
+  levels: isFalse(LEVELS)
+    ? false
+    : LEVELS.split(/\s*,\s*/).map((v) => Number(v)),
   avatarProxy,
   oauthUrl,
   markdown,

package/src/controller/comment.js

@@ -305,6 +305,50 @@ module.exports = class extends BaseRest {
           );
         }
 
+        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 }) => {
+              if (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;
+          });
+        }
+
         return this.json({
           page,
           totalPages: Math.ceil(rootCount / pageSize),

package/src/extend/think.js

@@ -7,4 +7,15 @@ module.exports = {
   isPrevent(err) {
     return think.isError(err) && err.message === preventMessage;
   },
+  findLastIndex(arr, fn) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+      const ret = fn(arr[i], i, arr);
+      if (!ret) {
+        continue;
+      }
+      return i;
+    }
+
+    return -1;
+  },
 };

package/src/service/storage/cloudbase.js

@@ -10,6 +10,7 @@ const app = cloudbase.init({
 
 const db = app.database();
 const _ = db.command;
+const $ = db.command.aggregate;
 const collections = {};
 
 module.exports = class extends Base {
@@ -90,10 +91,10 @@ module.exports = class extends Base {
     return filter;
   }
 
-  where(instance, where) {
+  where(instance, where, method = 'where') {
     const filter = this.parseWhere(where);
     if (!where._complex) {
-      return instance.where(filter);
+      return instance[method](filter);
     }
 
     const filters = [];
@@ -106,7 +107,7 @@ module.exports = class extends Base {
         ...filter,
       });
     }
-    return instance.where(_[where._complex._logic](...filters));
+    return instance[method](_[where._complex._logic](...filters));
   }
 
   async _select(where, { desc, limit, offset, field } = {}) {
@@ -147,10 +148,24 @@ module.exports = class extends Base {
     return data;
   }
 
-  async count(where = {}) {
-    const instance = await this.collection(this.tableName);
-    const { total } = await this.where(instance, where).count();
-    return total;
+  async count(where = {}, { group } = {}) {
+    let instance = await this.collection(this.tableName);
+    if (!group) {
+      instance = this.where(instance, where);
+      const { total } = await instance.count();
+      return total;
+    }
+
+    const _id = {};
+    group.forEach((f) => {
+      _id[f] = `$${f}`;
+    });
+    instance = instance.aggregate();
+    this.where(instance, where, 'match');
+    instance = instance.group({ _id, count: $.sum(1) });
+    const { data } = await instance.end();
+
+    return data.map(({ _id, count }) => ({ ..._id, count }));
   }
 
   async add(data) {

package/src/service/storage/deta.js

@@ -184,16 +184,47 @@ module.exports = class extends Base {
     return data;
   }
 
-  async count(where = {}) {
-    const conditions = this.where(where);
-    if (think.isArray(conditions)) {
-      return Promise.all(
-        conditions.map((condition) => this.count(condition))
-      ).then((counts) => counts.reduce((a, b) => a + b, 0));
+  async count(where = {}, { group } = {}) {
+    if (!group) {
+      const conditions = this.where(where);
+      if (think.isArray(conditions)) {
+        return Promise.all(
+          conditions.map((condition) => this.count(condition))
+        ).then((counts) => counts.reduce((a, b) => a + b, 0));
+      }
+
+      const { count } = await this.instance.fetch(conditions);
+      return count;
     }
 
-    const { count } = await this.instance.fetch(conditions);
-    return count;
+    const counts = [];
+    for (let i = 0; i < group.length; i++) {
+      const groupName = group[i];
+      if (!where._complex || !Array.isArray(where._complex[groupName])) {
+        continue;
+      }
+
+      const groupFlatValue = {};
+      group.slice(0, i).forEach((group) => {
+        groupFlatValue[group] = null;
+      });
+
+      for (let j = 0; j < where._complex[groupName][1].length; j++) {
+        const groupWhere = {
+          ...where,
+          ...groupFlatValue,
+          _complex: undefined,
+          [groupName]: where._complex[groupName][1][j],
+        };
+        const num = await this.count(groupWhere);
+        counts.push({
+          ...groupFlatValue,
+          [groupName]: where._complex[groupName][1][j],
+          count: num,
+        });
+      }
+    }
+    return counts;
   }
 
   async add(data) {

package/src/service/storage/github.js

@@ -287,10 +287,25 @@ module.exports = class extends Base {
   }
 
   // eslint-disable-next-line no-unused-vars
-  async count(where = {}, options = {}) {
+  async count(where = {}, { group } = {}) {
     const instance = await this.collection(this.tableName);
     const data = this.where(instance, where);
-    return data.length;
+    if (!group) {
+      return data.length;
+    }
+
+    const counts = {};
+    for (let i = 0; i < data.length; i++) {
+      const key = group.map((field) => data[field]).join();
+      if (!counts[key]) {
+        counts[key] = { count: 0 };
+        group.forEach((field) => {
+          counts[key][field] = data[field];
+        });
+      }
+      counts[key].count += 1;
+    }
+    return Object.keys(counts);
   }
 
   async add(

package/src/service/storage/leancloud.js

@@ -128,12 +128,47 @@ module.exports = class extends Base {
 
   async count(where = {}, options = {}) {
     const instance = this.where(this.tableName, where);
-    return instance.count(options).catch((e) => {
-      if (e.code === 101) {
-        return 0;
+    if (!options.group) {
+      return instance.count(options).catch((e) => {
+        if (e.code === 101) {
+          return 0;
+        }
+        throw e;
+      });
+    }
+
+    // todo: query optimize
+    const counts = [];
+    for (let i = 0; i < options.group.length; i++) {
+      const groupName = options.group[i];
+      if (!where._complex || !Array.isArray(where._complex[groupName])) {
+        continue;
       }
-      throw e;
-    });
+
+      const groupFlatValue = {};
+      options.group.slice(0, i).forEach((group) => {
+        groupFlatValue[group] = null;
+      });
+
+      for (let j = 0; j < where._complex[groupName][1].length; j++) {
+        const groupWhere = {
+          ...where,
+          ...groupFlatValue,
+          _complex: undefined,
+          [groupName]: where._complex[groupName][1][j],
+        };
+        const num = await this.count(groupWhere, {
+          ...options,
+          group: undefined,
+        });
+        counts.push({
+          ...groupFlatValue,
+          [groupName]: where._complex[groupName][1][j],
+          count: num,
+        });
+      }
+    }
+    return counts;
   }
 
   async add(

package/src/service/storage/mongodb.js

@@ -114,10 +114,17 @@ module.exports = class extends Base {
     }));
   }
 
-  async count(where = {}) {
+  async count(where = {}, { group } = {}) {
     const instance = this.mongo(this.tableName);
     this.where(instance, where);
-    return instance.count();
+    if (group) {
+      instance.group(group);
+    }
+    const data = await instance.count({ raw: group });
+    if (!Array.isArray(data)) {
+      return data;
+    }
+    return data.map(({ _id, total: count }) => ({ ..._id, count }));
   }
 
   async add(data) {

package/src/service/storage/mysql.js

@@ -50,10 +50,16 @@ module.exports = class extends Base {
     return data.map(({ id, ...cmt }) => ({ ...cmt, objectId: id }));
   }
 
-  async count(where = {}) {
+  async count(where = {}, { group } = {}) {
     const instance = this.model(this.tableName);
     instance.where(this.parseWhere(where));
-    return instance.count();
+    if (!group) {
+      return instance.count();
+    }
+
+    instance.field([...group, 'COUNT(*) as count']);
+    instance.group(group);
+    return instance.select();
   }
 
   async add(data) {

package/src/service/storage/postgresql.js

@@ -26,7 +26,13 @@ module.exports = class extends MySQL {
   async count(...args) {
     let result = await super.count(...args);
     try {
-      result = parseInt(result);
+      if (Array.isArray(result)) {
+        result.forEach((r) => {
+          r.count = parseInt(r.count);
+        });
+      } else {
+        result = parseInt(result);
+      }
     } catch (e) {
       console.log(e);
     }