@waline/vercel 1.3.1 → 1.5.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@waline/vercel",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "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') {

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/controller/oauth.js

@@ -24,7 +24,10 @@ module.exports = class extends think.Controller {
         type,
       })}`;
       return this.redirect(
-        `${oauthUrl}/${type}?${qs.stringify({ redirect: redirectUrl })}`
+        `${oauthUrl}/${type}?${qs.stringify({
+          redirect: redirectUrl,
+          state: this.ctx.state.token,
+        })}`
       );
     }
 
@@ -38,7 +41,10 @@ module.exports = class extends think.Controller {
         redirect,
         type,
       })}`;
-      params.state = qs.stringify({ redirect: redirectUrl, state: '' });
+      params.state = qs.stringify({
+        redirect: redirectUrl,
+        state: this.ctx.state.token || '',
+      });
     }
 
     const user = await request({
@@ -83,7 +89,7 @@ module.exports = class extends think.Controller {
         objectId: current.objectId,
       });
 
-      return this.success();
+      return this.redirect('/ui/profile');
     }
 
     const userByEmail = await this.modelInstance.select({ email: user.email });

package/src/controller/user.js

@@ -78,7 +78,7 @@ module.exports = class extends BaseRest {
   }
 
   async putAction() {
-    const { display_name, url, password, github } = this.post();
+    const { display_name, url, password } = this.post();
     const { objectId } = this.ctx.state.userInfo;
 
     const updateData = {};
@@ -95,9 +95,13 @@ module.exports = class extends BaseRest {
       updateData.password = new PasswordHash().hashPassword(password);
     }
 
-    if (think.isString(github)) {
-      updateData.github = github;
-    }
+    const socials = ['github', 'twitter', 'facebook', 'google', 'weibo', 'qq'];
+    socials.forEach((social) => {
+      const nextSocial = this.post(social);
+      if (think.isString(nextSocial)) {
+        updateData[social] = nextSocial;
+      }
+    });
 
     if (think.isEmpty(updateData)) {
       return this.success();

package/src/logic/base.js

@@ -79,5 +79,6 @@ module.exports = class extends think.Logic {
     userInfo.avatar = avatarUrl;
     userInfo.mailMd5 = helper.md5(userInfo.email);
     this.ctx.state.userInfo = userInfo;
+    this.ctx.state.token = token;
   }
 };

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();
+  }
+};