@waline/vercel 1.26.3 → 1.26.4

package/dist/src/service/storage/leancloud.js

@@ -0,0 +1,430 @@
+const AV = require('leancloud-storage');
+const Base = require('./base');
+const { LEAN_ID, LEAN_KEY, LEAN_MASTER_KEY, LEAN_SERVER } = process.env;
+
+if (LEAN_ID && LEAN_KEY && LEAN_MASTER_KEY) {
+  AV.Cloud.useMasterKey(true);
+  AV.init({
+    appId: LEAN_ID,
+    appKey: LEAN_KEY,
+    masterKey: LEAN_MASTER_KEY,
+    // required for leancloud china
+    serverURL: LEAN_SERVER,
+  });
+}
+module.exports = class extends Base {
+  parseWhere(className, where) {
+    const instance = new AV.Query(className);
+
+    if (think.isEmpty(where)) {
+      return instance;
+    }
+
+    for (const k in where) {
+      if (k === '_complex') {
+        continue;
+      }
+
+      if (think.isString(where[k])) {
+        instance.equalTo(k, where[k]);
+        continue;
+      }
+
+      if (where[k] === undefined) {
+        instance.doesNotExist(k);
+      }
+
+      if (Array.isArray(where[k])) {
+        if (where[k][0]) {
+          const handler = where[k][0].toUpperCase();
+
+          switch (handler) {
+            case 'IN':
+              instance.containedIn(k, where[k][1]);
+              break;
+            case 'NOT IN':
+              instance.notContainedIn(k, where[k][1]);
+              break;
+            case 'LIKE': {
+              const first = where[k][1][0];
+              const last = where[k][1].slice(-1);
+
+              if (first === '%' && last === '%') {
+                instance.contains(k, where[k][1].slice(1, -1));
+              } else if (first === '%') {
+                instance.endsWith(k, where[k][1].slice(1));
+              } else if (last === '%') {
+                instance.startsWith(k, where[k][1].slice(0, -1));
+              }
+              break;
+            }
+            case '!=':
+              instance.notEqualTo(k, where[k][1]);
+              break;
+            case '>':
+              instance.greaterThan(k, where[k][1]);
+              break;
+          }
+        }
+      }
+    }
+
+    return instance;
+  }
+
+  where(className, where) {
+    if (!where._complex) {
+      return this.parseWhere(className, where);
+    }
+
+    const filters = [];
+
+    for (const k in where._complex) {
+      if (k === '_logic') {
+        continue;
+      }
+
+      const filter = this.parseWhere(className, {
+        ...where,
+        [k]: where._complex[k],
+      });
+
+      filters.push(filter);
+    }
+
+    return AV.Query[where._complex._logic](...filters);
+  }
+
+  async _select(where, { desc, limit, offset, field } = {}) {
+    const instance = this.where(this.tableName, where);
+
+    if (desc) {
+      instance.descending(desc);
+    }
+    if (limit) {
+      instance.limit(limit);
+    }
+    if (offset) {
+      instance.skip(offset);
+    }
+    if (field) {
+      instance.select(field);
+    }
+
+    const data = await instance.find().catch((e) => {
+      if (e.code === 101) {
+        return [];
+      }
+      throw e;
+    });
+
+    return data.map((item) => item.toJSON());
+  }
+
+  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 === 100);
+
+    return data;
+  }
+
+  async _getCmtGroupByMailUserIdCache(key, where) {
+    if (
+      this.tableName !== 'Comment' ||
+      key !== 'user_id_mail' ||
+      !think.isArray(think.config('levels'))
+    ) {
+      return [];
+    }
+
+    const cacheTableName = `cache_group_count_${key}`;
+    const currentTableName = this.tableName;
+
+    this.tableName = cacheTableName;
+    const cacheData = await this.select({ _complex: where._complex });
+
+    this.tableName = currentTableName;
+
+    return cacheData;
+  }
+
+  async _setCmtGroupByMailUserIdCache(key, data) {
+    if (
+      this.tableName !== 'Comment' ||
+      key !== 'user_id_mail' ||
+      !think.isArray(think.config('levels'))
+    ) {
+      return;
+    }
+
+    const cacheTableName = `cache_group_count_${key}`;
+    const currentTableName = this.tableName;
+
+    this.tableName = cacheTableName;
+
+    await think.promiseAllQueue(
+      data.map((item) => {
+        if (item.user_id && !think.isString(item.user_id)) {
+          item.user_id = item.user_id.toString();
+        }
+
+        return this.add(item);
+      }),
+      1
+    );
+    this.tableName = currentTableName;
+  }
+
+  async _updateCmtGroupByMailUserIdCache(data, method) {
+    if (
+      this.tableName !== 'Comment' ||
+      !think.isArray(think.config('levels'))
+    ) {
+      return;
+    }
+
+    if (!data.user_id && !data.mail) {
+      return;
+    }
+
+    const cacheTableName = `cache_group_count_user_id_mail`;
+    const cacheData = await this.select({
+      _complex: {
+        _logic: 'or',
+        user_id: think.isObject(data.user_id)
+          ? data.user_id.toString()
+          : data.user_id,
+        mail: data.mail,
+      },
+    });
+
+    if (think.isEmpty(data)) {
+      return;
+    }
+
+    let count = cacheData[0].count;
+
+    switch (method) {
+      case 'add':
+        if (data.status === 'approved') {
+          count += 1;
+        }
+        break;
+      case 'udpate_status':
+        if (data.status === 'approved') {
+          count += 1;
+        } else {
+          count -= 1;
+        }
+        break;
+      case 'delete':
+        count -= 1;
+        break;
+    }
+
+    const currentTableName = this.tableName;
+
+    this.tableName = cacheTableName;
+    await this.update({ count }, { objectId: cacheData[0].objectId }).catch(
+      (e) => {
+        if (e.code === 101) {
+          return;
+        }
+        throw e;
+      }
+    );
+    this.tableName = currentTableName;
+  }
+
+  async count(where = {}, options = {}) {
+    const instance = this.where(this.tableName, where);
+
+    if (!options.group) {
+      return instance.count(options).catch((e) => {
+        if (e.code === 101) {
+          return 0;
+        }
+        throw e;
+      });
+    }
+
+    // get group count cache by group field where data
+    const cacheData = await this._getCmtGroupByMailUserIdCache(
+      options.group.join('_'),
+      where
+    );
+
+    if (!where._complex) {
+      if (cacheData.length) {
+        return cacheData;
+      }
+
+      const counts = await this.select(where, { field: options.group });
+      const countsMap = {};
+
+      for (let i = 0; i < counts.length; i++) {
+        const key = options.group
+          .map((item) => counts[i][item] || undefined)
+          .join('_');
+
+        if (!countsMap[key]) {
+          countsMap[key] = {};
+
+          for (let j = 0; j < options.group.length; j++) {
+            const field = options.group[j];
+
+            countsMap[key][field] = counts[i][field];
+          }
+          countsMap[key].count = 0;
+        }
+        countsMap[key].count += 1;
+      }
+
+      const ret = Object.values(countsMap);
+
+      // cache data
+      await this._setCmtGroupByMailUserIdCache(options.group.join('_'), ret);
+
+      return ret;
+    }
+
+    const cacheDataMap = {};
+
+    for (let i = 0; i < cacheData.length; i++) {
+      const key = options.group
+        .map((item) => cacheData[i][item] || undefined)
+        .join('_');
+
+      cacheDataMap[key] = cacheData[i];
+    }
+
+    const counts = [];
+    const countsPromise = [];
+
+    for (let i = 0; i < options.group.length; i++) {
+      const groupName = options.group[i];
+
+      if (!where._complex || !Array.isArray(where._complex[groupName])) {
+        continue;
+      }
+
+      const groupFlatValue = {};
+
+      options.group.slice(0, i).forEach((group) => {
+        groupFlatValue[group] = undefined;
+      });
+
+      for (let j = 0; j < where._complex[groupName][1].length; j++) {
+        const cacheKey = options.group
+          .map(
+            (item) =>
+              ({
+                ...groupFlatValue,
+                [groupName]: where._complex[groupName][1][j],
+              }[item] || undefined)
+          )
+          .join('_');
+
+        if (cacheDataMap[cacheKey]) {
+          continue;
+        }
+
+        const groupWhere = {
+          ...where,
+          ...groupFlatValue,
+          _complex: undefined,
+          [groupName]: where._complex[groupName][1][j],
+        };
+        const countPromise = this.count(groupWhere, {
+          ...options,
+          group: undefined,
+        }).then((num) => {
+          counts.push({
+            ...groupFlatValue,
+            [groupName]: where._complex[groupName][1][j],
+            count: num,
+          });
+        });
+
+        countsPromise.push(countPromise);
+      }
+    }
+
+    await think.promiseAllQueue(countsPromise, 1);
+    // cache data
+    await this._setCmtGroupByMailUserIdCache(options.group.join('_'), counts);
+
+    return [...cacheData, ...counts];
+  }
+
+  async add(
+    data,
+    { access: { read = true, write = true } = { read: true, write: true } } = {}
+  ) {
+    const Table = AV.Object.extend(this.tableName);
+    const instance = new Table();
+
+    const REVERSED_KEYS = ['objectId', 'createdAt', 'updatedAt'];
+
+    for (const k in data) {
+      if (REVERSED_KEYS.includes(k)) {
+        continue;
+      }
+      instance.set(k, data[k]);
+    }
+
+    const acl = new AV.ACL();
+
+    acl.setPublicReadAccess(read);
+    acl.setPublicWriteAccess(write);
+    instance.setACL(acl);
+
+    const resp = await instance.save();
+
+    await this._updateCmtGroupByMailUserIdCache(data, 'add');
+
+    return resp.toJSON();
+  }
+
+  async update(data, where) {
+    const instance = this.where(this.tableName, where);
+    const ret = await instance.find();
+
+    return Promise.all(
+      ret.map(async (item) => {
+        const _oldStatus = item.get('status');
+
+        if (think.isFunction(data)) {
+          item.set(data(item.toJSON()));
+        } else {
+          item.set(data);
+        }
+        const _newStatus = item.get('status');
+
+        if (_newStatus && _oldStatus !== _newStatus) {
+          await this._updateCmtGroupByMailUserIdCache(data, 'update_status');
+        }
+
+        const resp = await item.save();
+
+        return resp.toJSON();
+      })
+    );
+  }
+
+  async delete(where) {
+    const instance = this.where(this.tableName, where);
+    const data = await instance.find();
+
+    await this._updateCmtGroupByMailUserIdCache(data, 'delete');
+
+    return AV.Object.destroyAll(data);
+  }
+};

package/dist/src/service/storage/mongodb.js

@@ -0,0 +1,179 @@
+const { ObjectID: ObjectId } = require('think-mongo/lib/model');
+const Base = require('./base');
+
+module.exports = class extends Base {
+  parseWhere(where) {
+    if (think.isEmpty(where)) {
+      return {};
+    }
+
+    const filter = {};
+    const parseKey = (k) => (k === 'objectId' ? '_id' : k);
+
+    for (let k in where) {
+      if (k === '_complex') {
+        continue;
+      }
+      if (think.isString(where[k])) {
+        filter[parseKey(k)] = {
+          $eq: k === 'objectId' ? ObjectId(where[k]) : where[k],
+        };
+        continue;
+      }
+      if (where[k] === undefined) {
+        filter[parseKey(k)] = { $eq: null };
+      }
+      if (Array.isArray(where[k])) {
+        if (where[k][0]) {
+          const handler = where[k][0].toUpperCase();
+
+          switch (handler) {
+            case 'IN':
+              if (k === 'objectId') {
+                filter[parseKey(k)] = { $in: where[k][1].map(ObjectId) };
+              } else {
+                filter[parseKey(k)] = {
+                  $regex: new RegExp(`^(${where[k][1].join('|')})$`),
+                };
+              }
+              break;
+            case 'NOT IN':
+              filter[parseKey(k)] = {
+                $nin:
+                  k === 'objectId' ? where[k][1].map(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));
+              }
+
+              if (reg) {
+                filter[parseKey(k)] = { $regex: reg };
+              }
+              break;
+            }
+            case '!=':
+              filter[parseKey(k)] = { $ne: where[k][1] };
+              break;
+            case '>':
+              filter[parseKey(k)] = { $gt: where[k][1] };
+              break;
+          }
+        }
+      }
+    }
+
+    return filter;
+  }
+
+  where(instance, where) {
+    const filter = this.parseWhere(where);
+
+    if (!where._complex) {
+      return instance.where(filter);
+    }
+
+    const filters = [];
+
+    for (const k in where._complex) {
+      if (k === '_logic') {
+        continue;
+      }
+      filters.push({
+        ...this.parseWhere({ [k]: where._complex[k] }),
+        ...filter,
+      });
+    }
+
+    return instance.where({
+      // $or, $and, $not, $nor
+      [`$${where._complex._logic}`]: filters,
+    });
+  }
+
+  async select(where, { desc, limit, offset, field } = {}) {
+    const instance = this.mongo(this.tableName);
+
+    this.where(instance, where);
+    if (desc) {
+      instance.order(`${desc} DESC`);
+    }
+    if (limit || offset) {
+      instance.limit(offset || 0, limit);
+    }
+    if (field) {
+      instance.field(field);
+    }
+
+    const data = await instance.select();
+
+    return data.map(({ _id, ...cmt }) => ({
+      ...cmt,
+      objectId: _id.toString(),
+    }));
+  }
+
+  async count(where = {}, { group } = {}) {
+    const instance = this.mongo(this.tableName);
+
+    this.where(instance, where);
+    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) {
+    if (data.objectId) {
+      data._id = data.objectId;
+      delete data.objectId;
+    }
+
+    const instance = this.mongo(this.tableName);
+    const id = await instance.add(data);
+
+    return { ...data, objectId: id.toString() };
+  }
+
+  async update(data, where) {
+    const instance = this.mongo(this.tableName);
+
+    this.where(instance, where);
+    const list = await instance.select();
+
+    return Promise.all(
+      list.map(async (item) => {
+        const updateData = typeof data === 'function' ? data(item) : data;
+        const instance = this.mongo(this.tableName);
+
+        this.where(instance, where);
+        await instance.update(updateData);
+
+        return { ...item, ...updateData };
+      })
+    );
+  }
+
+  async delete(where) {
+    const instance = this.mongo(this.tableName);
+
+    this.where(instance, where);
+
+    return instance.delete();
+  }
+};

package/dist/src/service/storage/mysql.js

@@ -0,0 +1,123 @@
+const Base = require('./base');
+
+module.exports = class extends Base {
+  parseWhere(filter) {
+    const where = {};
+
+    if (think.isEmpty(filter)) {
+      return where;
+    }
+
+    for (const k in filter) {
+      if (k === 'objectId' || k === 'objectid') {
+        where.id = filter[k];
+        continue;
+      }
+
+      if (k === '_complex') {
+        where[k] = this.parseWhere(filter[k]);
+        continue;
+      }
+
+      if (filter[k] === undefined) {
+        where[k] = null;
+        continue;
+      }
+
+      if (Array.isArray(filter[k])) {
+        if (filter[k][0] === 'IN' && !filter[k][1].length) {
+          continue;
+        }
+        if (think.isDate(filter[k][1])) {
+          filter[k][1] = think.datetime(filter[k][1]);
+        }
+      }
+
+      where[k] = filter[k];
+    }
+
+    return where;
+  }
+
+  async select(where, { desc, limit, offset, field } = {}) {
+    const instance = this.model(this.tableName);
+
+    instance.where(this.parseWhere(where));
+    if (desc) {
+      instance.order({ [desc]: 'DESC' });
+    }
+    if (limit || offset) {
+      instance.limit(offset || 0, limit);
+    }
+    if (field) {
+      field.push('id');
+      instance.field(field);
+    }
+
+    const data = await instance.select();
+
+    return data.map(({ id, ...cmt }) => ({ ...cmt, objectId: id }));
+  }
+
+  async count(where = {}, { group } = {}) {
+    const instance = this.model(this.tableName);
+
+    instance.where(this.parseWhere(where));
+    if (!group) {
+      return instance.count();
+    }
+
+    instance.field([...group, 'COUNT(*) as count'].join(','));
+    instance.group(group);
+
+    return instance.select();
+  }
+
+  async add(data) {
+    if (data.objectId) {
+      data.id = data.objectId;
+      delete data.objectId;
+    }
+    const date = new Date();
+
+    if (!data.createdAt) data.createdAt = date;
+    if (!data.updatedAt) data.updatedAt = date;
+
+    const instance = this.model(this.tableName);
+    const id = await instance.add(data);
+
+    return { ...data, objectId: id };
+  }
+
+  async update(data, where) {
+    const list = await this.model(this.tableName)
+      .where(this.parseWhere(where))
+      .select();
+
+    return Promise.all(
+      list.map(async (item) => {
+        const updateData = typeof data === 'function' ? data(item) : data;
+
+        await this.model(this.tableName)
+          .where({ id: item.id })
+          .update(updateData);
+
+        return { ...item, ...updateData };
+      })
+    );
+  }
+
+  async delete(where) {
+    const instance = this.model(this.tableName);
+
+    return instance.where(this.parseWhere(where)).delete();
+  }
+
+  async setSeqId(id) {
+    const instance = this.model(this.tableName);
+
+    return instance.query(
+      `ALTER TABLE ${instance.tableName} AUTO_INCREMENT = ${id};`
+    );
+  }
+};