@waline/vercel 1.3.2 → 1.5.1

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@waline/vercel",
-  "version": "1.3.2",
+  "version": "1.5.1",
   "description": "vercel server for waline comment system",
   "repository": "https://github.com/walinejs/waline",
   "license": "MIT",
   "author": "lizheming <i@imnerd.org>",
   "dependencies": {
+    "@byteinspire/api": "^1.0.12",
     "@cloudbase/node-sdk": "^2.7.1",
     "@koa/cors": "^3.1.0",
     "akismet": "^2.0.6",

package/src/config/config.js

@@ -17,6 +17,7 @@ const {
   AVATAR_PROXY,
   GITHUB_TOKEN,
   DETA_PROJECT_KEY,
+  INSPIRECLOUD_SERVICE_SECRET,
   OAUTH_URL,
 
   MARKDOWN_CONFIG = '{}',
@@ -62,6 +63,9 @@ if (LEAN_KEY) {
 } else if (DETA_PROJECT_KEY) {
   storage = 'deta';
   jwtKey = jwtKey || DETA_PROJECT_KEY;
+} else if (INSPIRECLOUD_SERVICE_SECRET) {
+  storage = 'inspirecloud';
+  jwtKey = jwtKey || INSPIRECLOUD_SERVICE_SECRET;
 }
 
 if (think.env === 'cloudbase' && storage === 'sqlite') {
@@ -101,7 +105,7 @@ module.exports = {
   forbiddenWords,
   disallowIPList: [],
   secureDomains: SECURE_DOMAINS ? SECURE_DOMAINS.split(/\s*,\s*/) : undefined,
-  disableUserAgent: !isFalse(DISABLE_USERAGENT),
+  disableUserAgent: DISABLE_USERAGENT && !isFalse(DISABLE_USERAGENT),
   avatarProxy,
   oauthUrl,
   markdown,

package/src/config/middleware.js

@@ -3,6 +3,8 @@ const routerREST = require('think-router-rest');
 const isDev = think.env === 'development';
 const isTcb = think.env === 'cloudbase';
 const isDeta = think.env === 'deta' || process.env.DETA_RUNTIME === 'true';
+const isAliyunFC =
+  think.env === 'aliyun-fc' || Boolean(process.env.FC_RUNTIME_VERSION);
 
 module.exports = [
   {
@@ -15,7 +17,7 @@ module.exports = [
     options: {
       logRequest: isDev,
       sendResponseTime: isDev,
-      requestTimeoutCallback: isTcb || isDeta ? false : () => {},
+      requestTimeoutCallback: isTcb || isDeta || isAliyunFC ? false : () => {},
     },
   },
 

package/src/controller/comment.js

@@ -4,6 +4,7 @@ const BaseRest = require('./rest');
 const akismet = require('../service/akismet');
 const { getMarkdownParser } = require('../service/markdown');
 
+const markdownParser = getMarkdownParser();
 async function formatCmt(
   { ua, user_id, ...comment },
   users = [],
@@ -39,6 +40,7 @@ async function formatCmt(
     comment.mail ? comment.mail.toLowerCase() : comment.mail
   );
 
+  comment.comment = markdownParser(comment.comment);
   return comment;
 }
 
@@ -49,8 +51,6 @@ module.exports = class extends BaseRest {
       `storage/${this.config('storage')}`,
       'Comment'
     );
-
-    this.parser = getMarkdownParser();
   }
 
   async getAction() {
@@ -248,17 +248,14 @@ module.exports = class extends BaseRest {
       rid,
       ua,
       url,
+      comment,
       ip: this.ctx.ip,
       insertedAt: new Date(),
-      comment: this.parser(comment),
       user_id: this.ctx.state.userInfo.objectId,
     };
 
     if (pid) {
-      data.comment = data.comment.replace(
-        '<p>',
-        `<p><a class="at" href="#${pid}">@${at}</a>: `
-      );
+      data.comment = `[@${at}](#${pid}): ` + data.comment;
     }
 
     think.logger.debug('Post Comment initial Data:', data);

package/src/service/storage/inspirecloud.js

@@ -0,0 +1,152 @@
+const inspirecloud = require('@byteinspire/api');
+const Base = require('./base');
+
+module.exports = class extends Base {
+  constructor(tableName) {
+    super(tableName);
+    this.db = inspirecloud.db;
+  }
+
+  where(where) {
+    if (think.isEmpty(where)) {
+      return;
+    }
+
+    const _where = {};
+    const parseKey = (k) => (k === 'objectId' ? '_id' : k);
+    for (const k in where) {
+      if (think.isString(where[k])) {
+        _where[parseKey(k)] =
+          k === 'objectId' ? this.db.ObjectId(where[k]) : where[k];
+        continue;
+      }
+      if (where[k] === undefined) {
+        _where[parseKey(k)] = undefined;
+      }
+      if (Array.isArray(where[k])) {
+        if (where[k][0]) {
+          const handler = where[k][0].toUpperCase();
+          switch (handler) {
+            case 'IN':
+              _where[parseKey(k)] = this.db.in(
+                k === 'objectId'
+                  ? where[k][1].map(this.db.ObjectId)
+                  : where[k][1]
+              );
+              break;
+            case 'NOT IN':
+              _where[parseKey(k)] = this.db.nin(
+                k === 'objectId'
+                  ? where[k][1].map(this.db.ObjectId)
+                  : where[k][1]
+              );
+              break;
+            case 'LIKE': {
+              const first = where[k][1][0];
+              const last = where[k][1].slice(-1);
+              let reg;
+              if (first === '%' && last === '%') {
+                reg = new RegExp(where[k][1].slice(1, -1));
+              } else if (first === '%') {
+                reg = new RegExp(where[k][1].slice(1) + '$');
+              } else if (last === '%') {
+                reg = new RegExp('^' + where[k][1].slice(0, -1));
+              }
+              _where[parseKey(k)] = this.db.regex(reg);
+              break;
+            }
+            case '!=':
+              _where[parseKey(k)] = this.db.ne(where[k]);
+              break;
+            case '>':
+              _where[parseKey(k)] = this.db.gt(where[k]);
+              break;
+          }
+        }
+      }
+    }
+
+    return _where;
+  }
+
+  async _select(where, { desc, limit, offset, field } = {}) {
+    const instance = this.db.table(this.tableName);
+    const query = instance.where(this.where(where));
+
+    if (desc) {
+      query.sort({ [desc]: -1 });
+    }
+    if (limit) {
+      query.limit(limit);
+    }
+    if (offset) {
+      query.skip(offset);
+    }
+    if (field) {
+      const _field = {};
+      field.forEach((f) => {
+        _field[f] = 1;
+      });
+      query.projection(_field);
+    }
+
+    const data = await query.find();
+    data.forEach((item) => {
+      item.objectId = item._id.toString();
+      delete item._id;
+    });
+    return data;
+  }
+
+  async select(where, options = {}) {
+    let data = [];
+    let ret = [];
+    do {
+      options.offset = (options.offset || 0) + data.length;
+      ret = await this._select(where, options);
+      data = data.concat(ret);
+    } while (ret.length === 1000);
+
+    return data;
+  }
+
+  async count(where = {}) {
+    const instance = this.db.table(this.tableName);
+    const query = instance.where(this.where(where));
+
+    return query.count();
+  }
+
+  async add(data) {
+    const instance = this.db.table(this.tableName);
+    const tableData = instance.create(data);
+    await instance.save(tableData);
+
+    tableData.objectId = tableData._id.toString();
+    delete tableData._id;
+    return tableData;
+  }
+
+  async update(data, where) {
+    const instance = this.db.table(this.tableName);
+    const query = instance.where(this.where(where));
+    const items = await query.find();
+
+    return Promise.all(
+      items.map(async (item) => {
+        const updateData = typeof data === 'function' ? data(item) : data;
+        for (const k in updateData) {
+          item[k] = updateData[k];
+        }
+        await instance.save(item);
+        return item;
+      })
+    );
+  }
+
+  async delete(where) {
+    const instance = this.db.table(this.tableName);
+    const query = instance.where(this.where(where));
+    return query.delete();
+  }
+};