@waline/vercel 1.8.1 → 1.9.0

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@waline/vercel",
-  "version": "1.8.1",
+  "version": "1.9.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.9.0",
     "@koa/cors": "^3.2.0",
     "akismet": "^2.0.6",

package/src/config/config.js

@@ -17,7 +17,6 @@ const {
   AVATAR_PROXY,
   GITHUB_TOKEN,
   DETA_PROJECT_KEY,
-  INSPIRECLOUD_SERVICE_SECRET,
   OAUTH_URL,
 
   MARKDOWN_CONFIG = '{}',
@@ -64,9 +63,6 @@ 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/db.js

@@ -0,0 +1,56 @@
+const fs = require('fs/promises');
+const BaseRest = require('./rest');
+
+module.exports = class extends BaseRest {
+  async getAction() {
+    const exportData = {
+      type: 'waline',
+      version: 1,
+      time: Date.now(),
+      tables: ['Comment', 'Counter', 'Users'],
+      data: {
+        Comment: [],
+        Counter: [],
+        Users: [],
+      },
+    };
+
+    for (let i = 0; i < exportData.tables.length; i++) {
+      const tableName = exportData.tables[i];
+      const model = this.model(tableName);
+      const data = await model.select({});
+      exportData.data[tableName] = data;
+    }
+
+    return this.success(exportData);
+  }
+
+  async postAction() {
+    const file = this.file('file');
+    try {
+      const jsonText = await fs.readFile(file.path, 'utf-8');
+      const importData = JSON.parse(jsonText);
+      if (!importData || importData.type !== 'waline') {
+        return this.fail('import data format not support!');
+      }
+
+      for (let i = 0; i < importData.tables.length; i++) {
+        const tableName = importData.tables[i];
+        const model = this.model(tableName);
+
+        // delete all data at first
+        await model.delete({});
+        // then add data one by one
+        for (let j = 0; j < importData.data[tableName].length; j++) {
+          await model.add(importData.data[tableName][j]);
+        }
+      }
+      return this.success();
+    } catch (e) {
+      if (think.isPrevent(e)) {
+        return this.success();
+      }
+      return this.fail(e.message);
+    }
+  }
+};

package/src/logic/base.js

@@ -17,7 +17,13 @@ module.exports = class extends think.Logic {
       secureDomains = think.isArray(secureDomains)
         ? secureDomains
         : [secureDomains];
-      secureDomains.push('localhost', '127.0.0.1', 'github.com');
+      secureDomains.push(
+        'localhost',
+        '127.0.0.1',
+        'github.com',
+        'api.twitter.com',
+        'www.facebook.com'
+      );
 
       const match = secureDomains.some((domain) =>
         think.isFunction(domain.test)

package/src/logic/db.js

@@ -0,0 +1,30 @@
+const Base = require('./base');
+
+module.exports = class extends Base {
+  async __before(...args) {
+    await super.__before(...args);
+
+    const { userInfo } = this.ctx.state;
+    if (think.isEmpty(userInfo)) {
+      return this.fail(401);
+    }
+
+    if (userInfo.type !== 'administrator') {
+      return this.fail(403);
+    }
+  }
+
+  /**
+   * @api {GET} /db export site data
+   * @apiGroup Site
+   * @apiVersion  0.0.1
+   */
+  async getAction() {}
+
+  /**
+   * @api {GET} /db import site data
+   * @apiGroup Site
+   * @apiVersion  0.0.1
+   */
+  async postAction() {}
+};

package/src/service/storage/inspirecloud.js

@@ -1,180 +0,0 @@
-const inspirecloud = require('@byteinspire/api');
-const Base = require('./base');
-
-module.exports = class extends Base {
-  constructor(tableName) {
-    super(tableName);
-    this.db = inspirecloud.db;
-  }
-
-  parseWhere(where) {
-    const _where = {};
-    if (think.isEmpty(where)) {
-      return _where;
-    }
-
-    const parseKey = (k) => (k === 'objectId' ? '_id' : k);
-    for (const k in where) {
-      if (k === '_complex') {
-        continue;
-      }
-
-      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)] = {
-                $in:
-                  k === 'objectId'
-                    ? where[k][1].map(this.db.ObjectId)
-                    : where[k][1],
-              };
-              break;
-            case 'NOT IN':
-              _where[parseKey(k)] = {
-                $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)] = { $regex: reg };
-              break;
-            }
-            case '!=':
-              _where[parseKey(k)] = { $ne: where[k] };
-              break;
-            case '>':
-              _where[parseKey(k)] = { $gt: where[k] };
-              break;
-          }
-        }
-      }
-    }
-
-    return _where;
-  }
-
-  where(where) {
-    const filter = this.parseWhere(where);
-    if (!where._complex) {
-      return filter;
-    }
-
-    const filters = [];
-    for (const k in where._complex) {
-      if (k === '_logic') {
-        continue;
-      }
-
-      filters.push({
-        ...this.parseWhere({ [k]: where._complex[k] }),
-        ...filter,
-      });
-    }
-
-    return { [`$${where._complex._logic}`]: filters };
-  }
-
-  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 = [];
-    let offset = options.offset || 0;
-    do {
-      options.offset = offset + 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();
-  }
-};