@waline/vercel 1.3.0 → 1.4.1

package/package.json

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

package/src/controller/oauth.js

@@ -12,31 +12,39 @@ module.exports = class extends think.Controller {
   }
 
   async indexAction() {
-    const { code, type, redirect } = this.get();
+    const { code, oauth_verifier, oauth_token, type, redirect } = this.get();
     const { oauthUrl } = this.config();
 
-    if (!code) {
+    const hasCode =
+      type === 'twitter' ? oauth_token && oauth_verifier : Boolean(code);
+    if (!hasCode) {
       const { protocol, host } = this.ctx;
       const redirectUrl = `${protocol}://${host}/oauth?${qs.stringify({
         redirect,
         type,
       })}`;
       return this.redirect(
-        `${oauthUrl}/${type}?${qs.stringify({ redirect: redirectUrl })}`
+        `${oauthUrl}/${type}?${qs.stringify({
+          redirect: redirectUrl,
+          state: this.ctx.state.token,
+        })}`
       );
     }
 
     /**
      * user = { id, name, email, avatar,url };
      */
-    const params = { code };
+    const params = { code, oauth_verifier, oauth_token };
     if (type === 'facebook') {
       const { protocol, host } = this.ctx;
       const redirectUrl = `${protocol}://${host}/oauth?${qs.stringify({
         redirect,
         type,
       })}`;
-      params.state = qs.stringify({ redirect: redirectUrl, state: '' });
+      params.state = qs.stringify({
+        redirect: redirectUrl,
+        state: this.ctx.state.token || '',
+      });
     }
 
     const user = await request({
@@ -81,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/logic/oauth.js

@@ -2,9 +2,9 @@ const Base = require('./base');
 
 module.exports = class extends Base {
   /**
-   * @api {GET} /oauth/github  github oauth api
+   * @api {GET} /oauth oauth api
    * @apiGroup  OAuth
    * @apiVersion  0.0.1
    */
-  githubAction() {}
+  indexAction() {}
 };

package/src/service/storage/inspirecloud.js

@@ -0,0 +1,151 @@
+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();
+  }
+};