@abtnode/core 1.16.8-beta-186fd5aa → 1.16.8-next-c66e39c7

package/lib/states/user.js

@@ -1,34 +1,18 @@
 const pickBy = require('lodash/pickBy');
-const escapeStringRegexp = require('escape-string-regexp');
+const get = require('lodash/get');
 const pick = require('lodash/pick');
-const cloneDeep = require('lodash/cloneDeep');
-const logger = require('@abtnode/logger')('@abtnode/core:states:user');
 const { isValid } = require('@arcblock/did');
 const { PASSPORT_STATUS } = require('@abtnode/constant');
-const { upsertToPassports } = require('@abtnode/auth/lib/passport');
-const { fromAppDid } = require('@arcblock/did-ext');
+const { BaseState } = require('@abtnode/models');
+const { Sequelize, Op } = require('sequelize');
+const { updateConnectedAccount } = require('@abtnode/util/lib/user');
 
-const BaseState = require('./base');
 const { validateOwner } = require('../util');
 const { loginSchema } = require('../validators/user');
+const ExtendBase = require('./base');
 
 const isNullOrUndefined = (x) => x === undefined || x === null;
 
-/**
- * UserPassport
- * @typedef {Object} UserPassport
- * @property {string} id - id
- * @property {string[]} [type] - passport's type
- * @property {string[]} [issuer] - passport's issuer
- * @property {Date} [issuanceDate] - passport's issuanceDate
- * @property {string} [specVersion] - passport's specVersion
- * @property {string} name - passport's name
- * @property {string} [title] - passport's title
- * @property {string} [endpoint] - passport's endpoint
- * @property {string} [status] - passport's status
- * @property {string} role - passport's role
- */
-
 /**
  * Auth0Account
  * @typedef {Object} Auth0Account
@@ -66,126 +50,76 @@ const isNullOrUndefined = (x) => x === undefined || x === null;
  */
 
 /**
- * The Data structure of blocklet-service user
- * @typedef {Object} BlockletUser - Blocklet Service User Table
- * @property {string} _id - id
- * @property {('profile')} type - type of user
- * @property {string} fullName - user profile's name
- * @property {string} avatar - url of user's avatar, eg: bn://avatar/7f8848569405f8cdf8b1b2788ebf7d0f.jpg
- * @property {string} did - user's did -> 实际上变为 uid, 是不可变的；真正的 wallet-did 转移到 extraConfigs 中去了
- * @property {string} pk - user's publicKey
- * @property {UserPassport[]} passports - user's passport list
- * @property {boolean} approved - enable user to login
- * @property {string} locale - locale
- * @property {Object} [extra] - extra data of user
- * @property {Object} [extraConfigs] - extra data of user
- * @property {ConnectedAccount[]} [extraConfigs.connectedAccounts] - connectedAccounts
- * @property {('wallet'|'auth0')} [extraConfigs.sourceProvider] - sourceProvider, the main account provider
- * @property {Date} firstLoginAt - firstLoginAt
- * @property {Date} lastLoginAt - lastLoginAt
- * @property {string} lastLoginIp - lastLoginIp
- * @property {Date} createdAt - createdAt
- * @property {Date} updatedAt - updatedAt
- * @property {('owner'|'admin'|'member'|'guest'|string)} role - user's role deprecated
+ * @extends ExtendBase<import('@abtnode/models').UserState>
  */
+class User extends ExtendBase {
+  constructor(model, config, models) {
+    super(model, config);
 
-function updateConnectedAccount(connectedAccounts = [], connectedAccount = {}) {
-  const now = new Date().toISOString();
-  const filterAccounts = connectedAccounts.filter(Boolean);
-  const updated = cloneDeep(filterAccounts);
-  const updates = Array.isArray(connectedAccount) ? connectedAccount : [connectedAccount];
-  updates.filter(Boolean).forEach((x) => {
-    if (x.provider && x.did) {
-      const findAccountIndex = updated.findIndex((item) => item.provider === x.provider && item.did === x.did);
-      if (findAccountIndex > -1) {
-        updated[findAccountIndex] = {
-          ...filterAccounts[findAccountIndex],
-          ...x,
-          lastLoginAt: now,
-        };
-      } else {
-        updated.push({
-          ...x,
-          firstLoginAt: now,
-          lastLoginAt: now,
-        });
-      }
-    }
-  });
-
-  return updated;
-}
-
-class User extends BaseState {
-  constructor(baseDir, config = {}) {
-    super(baseDir, { filename: 'user.db', ...config });
-
-    this.onReady(() => {
-      this.ensureIndex({ fieldName: 'did', unique: true }, (error) => {
-        if (error) {
-          logger.error('ensure index failed', { error });
-        }
-      });
-    });
+    this.models = models;
+    this.passport = new BaseState(models.Passport, config);
+    this.connectedAccount = new BaseState(models.ConnectedAccount, config);
   }
 
-  /**
-   * Add a new user
-   * @param {BlockletUser} user - user data
-   * @returns {Promise<number>}
-   */
-  async add(user) {
+  // FIXME: @wangshijun wrap these in a transaction
+  async addUser(user) {
     if (!validateOwner(user)) {
       throw new Error('user is invalid');
     }
 
-    return this.insert({
+    // create user
+    await this.insert({
       ...user,
+      sourceProvider: user.sourceProvider || 'wallet',
       approved: !!user.approved,
     });
-  }
 
-  /**
-   * Update a user
-   * @param {BlockletUser} user - user data
-   * @returns {BlockletUser}
-   */
-  async update(user) {
-    if (!validateOwner(user)) {
-      throw new Error('user is invalid');
-    }
+    // create passports and connectedAccounts
+    await Promise.all((get(user, 'passports') || []).map((x) => this.passport.insert({ ...x, userDid: user.did })));
+    await Promise.all(
+      (get(user, 'connectedAccounts') || []).map((x) => this.connectedAccount.insert({ ...x, userDid: user.did }))
+    );
 
-    const [num, doc] = await super.update({ did: user.did }, { $set: user });
+    return this.getUser(user.did);
+  }
 
-    if (num === 0) {
-      throw new Error('user does not exist');
+  // FIXME: @wangshijun wrap these in a transaction
+  async updateUser(did, updates) {
+    const exist = await super.count({ did });
+    if (!exist) {
+      throw new Error(`user does not exist: ${did}`);
     }
 
-    return doc;
+    await super.update({ did }, { $set: updates });
+    await Promise.all(
+      (get(updates, 'passports') || []).map((x) => this.passport.upsert({ id: x.id }, { ...x, userDid: did }))
+    );
+    await Promise.all(
+      (get(updates, 'connectedAccounts') || []).map((x) =>
+        this.connectedAccount.upsert({ did: x.did }, { ...x, userDid: did })
+      )
+    );
+
+    return this.getUser(did);
   }
 
-  /**
-   * @param {string} did user did
-   * @param {string} id passport id
-   */
-  async revokePassportById({ did, id } = {}) {
+  async revokePassportById({ did, id }) {
     return this._setPassportStatusById({ did, id, status: PASSPORT_STATUS.REVOKED });
   }
 
-  async enablePassportById({ did, id } = {}) {
+  async enablePassportById({ did, id }) {
     return this._setPassportStatusById({ did, id, status: PASSPORT_STATUS.VALID });
   }
 
   /**
    * remove a user by user's did
-   * @param {string} did - the did of user
-   * @returns {number} deleted count
+   * @param {object} params
+   * @param {string} params.did - the did of user
    */
   async remove({ did }) {
     const num = await super.remove({ did });
-
     if (num === 0) {
-      throw new Error('user does not exist');
+      throw new Error(`user does not exist: ${did}`);
     }
 
     return num;
@@ -193,13 +127,12 @@ class User extends BaseState {
 
   /**
    * enable/disable user login
-   * @param {string} did user's did
-   * @param {boolean} approved enable/disable user login
-   * @returns {BlockletUser}
+   * @param {object} params
+   * @param {string} params.did user's did
+   * @param {boolean} params.approved enable/disable user login
    */
   async updateApproved({ did, approved }) {
-    const [num, doc] = await super.update({ did }, { $set: { approved } });
-
+    const [num, [doc]] = await super.update({ did }, { $set: { approved } });
     if (num === 0) {
       throw new Error(`user does not exist: ${did}`);
     }
@@ -209,13 +142,12 @@ class User extends BaseState {
 
   /**
    * update user's role
-   * @param {string} did user's did
-   * @param {BlockletUser.role} role user's role
-   * @returns {BlockletUser}
+   * @param {object} params
+   * @param {string} params.did user's did
+   * @param {string} params.role user's role
    */
   async updateRole({ did, role }) {
-    const [num, doc] = await super.update({ did }, { $set: { role } });
-
+    const [num, [doc]] = await super.update({ did }, { $set: { role } });
     if (num === 0) {
       throw new Error(`user does not exist: ${did}`);
     }
@@ -225,267 +157,134 @@ class User extends BaseState {
 
   /**
    * Get blocklet service user list
-   * @param {Object} query query params
-   * @param {('asc'|'desc')} sort query sort
-   * @param {any} paging query paging
-   * @returns {{list: BlockletUser[]; paging: any;}}
    */
-  async getUsers({ query, sort, paging: inputPaging } = {}) {
-    const { approved, role, search, connectedDid } = query || {};
-    const queryParamList = [];
-
-    // make query param
-    const queryParam = {};
+  async getUsers({ query, sort, paging } = {}) {
+    const where = {};
+    const { approved, role, search } = query || {};
 
-    if (!isNullOrUndefined(approved)) {
-      queryParam.approved = !!approved;
+    if (isNullOrUndefined(approved) === false) {
+      where.approved = approved;
     }
 
     if (search) {
       if (search.length > 50) {
         throw new Error('the length of search text should not more than 50');
       }
-
       if (isValid(search)) {
-        queryParam.did = search;
+        where.did = search;
       } else {
-        const reg = new RegExp(escapeStringRegexp(search), 'i');
-
-        queryParam.fullName = { $regex: reg };
+        where[Op.or] = [{ fullName: { [Op.like]: `%${search}%` } }, { email: { [Op.like]: `%${search}%` } }];
       }
     }
 
-    if (role && role !== '$all') {
+    if (role && role !== '$all' && !where.did) {
       if (role === '$none') {
-        queryParam.passports = { $size: 0 };
+        where.did = {
+          [Op.notIn]: Sequelize.literal('(SELECT DISTINCT userDid FROM passports)'),
+        };
       } else {
-        queryParam.passports = { $elemMatch: { name: role, status: PASSPORT_STATUS.VALID } };
+        where.did = {
+          [Op.in]: Sequelize.literal(
+            `(SELECT DISTINCT userDid FROM passports WHERE name = '${role}' AND status = '${PASSPORT_STATUS.VALID}')`
+          ),
+        };
       }
     }
 
-    // 根据 connectedDid 查询 user 信息（wallet 账户绑定 oauth 账户后，会有该字段）
-    if (connectedDid) {
-      queryParamList.push({
-        ...queryParam,
-        'extraConfigs.connectedAccounts.did': connectedDid,
-      });
-      // HACK: 在某些情况下，查询的条件可能是 version2 版本的用户 did，并且查村的 did 是派生出来的，没有实际的用户记录，只能通过这个条件查询出来
-      // version 1 的用户不需要通过这个条件来查询
-      queryParamList.push({
-        ...queryParam,
-        'extraConfigs.derivedAccount.did': connectedDid,
-      });
+    const sorting = pickBy(sort, (x) => !isNullOrUndefined(x));
+    if (!Object.keys(sorting).length) {
+      sorting.createdAt = -1;
     }
 
-    const sortParam = pickBy(sort, (x) => !isNullOrUndefined(x));
-
-    if (!Object.keys(sortParam).length) {
-      sortParam.createdAt = -1;
-    }
-
-    // get data
-    const { list, paging } = await this.paginate(
-      queryParamList.length > 0 ? { $or: queryParamList } : queryParam,
-      sortParam,
-      inputPaging
-    );
-
-    return {
-      list,
-      paging,
-    };
+    return this.paginate({ where }, sorting, paging);
   }
 
-  /**
-   * get user list by did list
-   * @param {string[]} dids user did list
-   * @returns {BlockletUser[]}
-   */
-  async getUsersByDids({ dids, query } = {}) {
+  async getUsersByDids({ dids, query }) {
     const { approved } = query || {};
-    const didList = dids || [];
-
-    const queryParam = {
-      did: { $in: didList },
-    };
-
-    if (!isNullOrUndefined(approved)) {
-      queryParam.approved = !!approved;
+    const condition = { did: dids };
+    if (isNullOrUndefined(approved) === false) {
+      condition.approved = !!approved;
     }
 
-    // get data
-    return this.find(queryParam);
+    return this.find({ where: condition });
   }
 
-  /**
-   * get user list by sourceId list
-   * @param {string[]} sourceIds user sourceId list
-   * @returns {BlockletUser[]}
-   */
-  async getUsersBySourceIds({ sourceIds, query } = {}) {
-    const { approved } = query || {};
-    const sourceIdList = sourceIds || [];
-
-    const queryParam = {
-      'extraConfigs.sourceId': { $in: sourceIdList },
-    };
-
-    if (!isNullOrUndefined(approved)) {
-      queryParam.approved = !!approved;
+  async countByPassport({ name, status = PASSPORT_STATUS.VALID }) {
+    if (name === '$none') {
+      return this.count({
+        where: {
+          did: {
+            [Op.notIn]: Sequelize.literal('(SELECT DISTINCT userDid FROM passports)'),
+          },
+        },
+      });
     }
 
-    // get data
-    return this.find(queryParam);
-  }
-
-  /**
-   * user 版本标准化，统一将 user 转换为最新的结构，结构参考 core/state/lib/states/user.js L12-L75
-   */
-  // 1: 没有 extraConfigs 字段
-  // 2: 有 source 和 extraConfigs 字段，oauth 账号的 extraConfigs 中包含 sourceId 和 sourceProvider 字段
-  // 3: 只有 extraConfigs 字段，且 extraConfigs.connectedAccounts 中包含 extraConfigs.sourceProvider 的 account
-  async normalize(user, { blockletSk }) {
-    if (!user) {
-      return user;
-    }
-    let version = 1;
-    if (user.extraConfigs) {
-      version = 2;
-
-      const connectedAccounts = user.extraConfigs?.connectedAccounts || [];
-      const sourceProvider = user.extraConfigs?.sourceProvider || '';
-      if (connectedAccounts.some((item) => item.provider === sourceProvider)) {
-        version = 3;
-      }
+    if (name === '$all') {
+      return this.count({});
     }
 
-    const versionMap = {
-      1: async () => {
-        const connectedAccounts = [
-          {
-            provider: 'wallet',
-            did: user.did,
-            pk: user.pk,
-            firstLoginAt: user.firstLoginAt,
-            lastLoginAt: user.lastLoginAt,
-          },
-        ];
-        const sourceProvider = 'wallet';
-        const updatedUser = await this.update({
-          did: user.did,
-          pk: user.pk,
-          extraConfigs: {
-            sourceProvider,
-            connectedAccounts,
-          },
-        });
-        return updatedUser;
+    return this.count({
+      distinct: true,
+      col: 'did',
+      where: {
+        did: {
+          [Op.in]: Sequelize.literal(
+            `(SELECT DISTINCT userDid FROM passports WHERE name = '${name}' AND status = '${status}')`
+          ),
+        },
       },
-      2: async () => {
-        // eslint-disable-next-line prefer-const
-        let { sourceId, sourceProvider, connectedAccounts = [] } = user.extraConfigs || {};
-        if (sourceId && sourceProvider) {
-          connectedAccounts = [
-            {
-              provider: sourceProvider,
-              id: sourceId,
-              did: user.did,
-              pk: user.pk,
-              firstLoginAt: user.firstLoginAt,
-              lastLoginAt: user.lastLoginAt,
-            },
-          ];
-        } else {
-          sourceProvider = 'wallet';
-          connectedAccounts.forEach((account) => {
-            if (account.id && blockletSk) {
-              const accountWallet = fromAppDid(account.id, blockletSk);
-              account.did = accountWallet.address;
-              account.pk = accountWallet.publicKey;
-              account.firstLoginAt = account.firstLoginAt || new Date().toISOString();
-              account.lastLoginAt = account.lastLoginAt || new Date().toISOString();
-            }
-          });
-          connectedAccounts.unshift({
-            provider: 'wallet',
-            did: user.did,
-            pk: user.pk,
-            firstLoginAt: user.firstLoginAt,
-            lastLoginAt: user.lastLoginAt,
-          });
-        }
-        const updatedUser = await this.update({
-          did: user.did,
-          pk: user.pk,
-          extraConfigs: {
-            sourceProvider,
-            connectedAccounts,
-          },
-          source: undefined,
-        });
-        return updatedUser;
-      },
-      3: () => {
-        return user;
-      },
-    };
-    return versionMap[version]();
+    });
   }
 
   /**
    * get user by did
    * @param {string} did user's did
-   * @returns {BlockletUser}
    */
-  async getUser(did, { enableConnectedAccount = false, enableNormalize = false, blockletSk } = {}) {
+  async getUser(did, { enableConnectedAccount = false } = {}) {
     let user = await this.findOne({ did });
-    if (enableConnectedAccount) {
-      if (!user) {
-        user = await this.findOne({
-          'extraConfigs.connectedAccounts.did': did,
-        });
-      } else if (user.extraConfig?.bindDid) {
-        // @deprecated 已经不存在 bindDid 字段
-        ({ user } = await this.findOne({ did: user.extraConfig.bindDid }));
+    let connectedAccounts = [];
+    let passports = [];
+
+    // search in connected accounts
+    if (!user && enableConnectedAccount) {
+      const connectedAccount = await this.connectedAccount.findOne({ did });
+      if (connectedAccount) {
+        user = await this.findOne({ did: connectedAccount.userDid });
       }
     }
-    if (enableNormalize) {
-      if (!blockletSk) {
-        throw new Error('Normalize user must provide blockletSk params');
-      }
-      return this.normalize(user, { blockletSk });
+
+    if (user) {
+      [connectedAccounts, passports] = await Promise.all([
+        this.connectedAccount.find({ userDid: user.did }),
+        this.passport.find({ userDid: user.did }),
+      ]);
+
+      user.connectedAccounts = connectedAccounts;
+      user.passports = passports;
     }
+
     return user;
   }
 
   /**
-   * @param {string} did user did
-   * @param {string} id passport id
-   * @param {string} status passport status
+   * @param {object} params
+   * @param {string} params.did user did
+   * @param {string} params.id passport id
+   * @param {string} params.status passport status
    */
-  async _setPassportStatusById({ did, id, status } = {}) {
-    const exist = await this.findOne({ did });
-
+  async _setPassportStatusById({ did, id, status }) {
+    const exist = this.passport.count({ id });
     if (!exist) {
-      throw new Error('did does not exist');
-    }
-
-    const passports = exist.passports || [];
-    const passport = passports.find((x) => x.id === id);
-
-    if (!passport) {
       throw new Error(`cannot find passport by id ${id}`);
     }
 
-    passport.status = status;
-
-    const [num, doc] = await super.update({ did }, { $set: { passports } });
-
+    const [num] = await this.passport.update({ id }, { $set: { status } });
     if (num === 0) {
-      throw new Error('user does not exist');
+      throw new Error('user passport does not exist');
     }
 
-    return doc;
+    return this.getUser(did);
   }
 
   /**
@@ -502,66 +301,58 @@ class User extends BaseState {
    * @param {string} user.lastLoginIp - lastLoginIp
    * @param {('owner'|'admin'|'member'|'guest'|string)} user.role - deprecated user's role
    */
-  async login(_user) {
-    const { error, value: user } = loginSchema.validate(_user);
+  async loginUser(raw) {
+    const { error, value: user } = loginSchema.validate(raw);
     if (error) {
       throw new Error(error);
     }
 
-    let updatedUser;
-    let action = '';
+    let updated;
+
     const now = new Date().toISOString();
-    const oldUser = await this.getUser(user.did, {
-      enableConnectedAccount: true,
-    });
-    const cloneData = cloneDeep(user);
-    const passports = upsertToPassports(
-      oldUser?.passports || [],
-      cloneData.passport && {
-        ...cloneData.passport,
-        lastLoginAt: now,
-      }
-    );
-    const mergeData = {
-      ...pick(cloneData, ['type', 'fullName', 'email', 'avatar', 'role', 'locale', 'extra', 'lastLoginIp', 'remark']),
-      did: user.did,
-      pk: user.pk,
-      passports,
+    const exist = await this.getUser(user.did, { enableConnectedAccount: true });
+
+    const updates = {
+      ...pick(user, ['fullName', 'email', 'avatar', 'role', 'locale', 'extra', 'lastLoginIp', 'remark']),
       lastLoginAt: now,
-      extraConfigs: {
-        sourceProvider: 'wallet',
-        connectedAccounts: [],
-      },
+      passports: user.passport ? [{ ...user.passport, lastLoginAt: now }] : [],
     };
 
-    if (oldUser) {
-      // update
-      action = 'update';
-      const extraConfigs = {
-        sourceProvider: oldUser?.extraConfigs?.sourceProvider || 'wallet',
-        connectedAccounts: updateConnectedAccount(
-          oldUser?.extraConfigs?.connectedAccounts || [],
-          cloneData.connectedAccount
-        ),
-      };
-      mergeData.extraConfigs = extraConfigs;
-      updatedUser = await this.update(mergeData);
+    if (exist) {
+      // update user, connectedAccount, passport
+      updates.connectedAccounts = updateConnectedAccount(exist.connectedAccounts, user.connectedAccount);
+      updated = await this.updateUser(user.did, updates);
     } else {
-      // insert
-      action = 'add';
-      mergeData.firstLoginAt = now;
-      mergeData.approved = true;
-      const connectedAccount = Array.isArray(cloneData.connectedAccount)
-        ? cloneData.connectedAccount.filter(Boolean)[0]
-        : cloneData.connectedAccount;
-
-      mergeData.extraConfigs = {
-        sourceProvider: connectedAccount.provider,
-        connectedAccounts: updateConnectedAccount([], cloneData.connectedAccount),
-      };
-      updatedUser = await this.add(mergeData);
+      // create user, connectedAccount, passport
+      updates.did = user.did;
+      updates.pk = user.pk;
+      updates.firstLoginAt = now;
+      updates.approved = true;
+      updates.connectedAccounts = updateConnectedAccount([], user.connectedAccount);
+      updates.sourceProvider = updates.connectedAccounts[0].provider;
+      updated = await this.addUser(updates);
     }
-    return { ...updatedUser, _action: action };
+
+    return { ...updated, _action: exist ? 'update' : 'add' };
+  }
+
+  async getUserByDid(did) {
+    return this.findOne({ did }, { did: 1, pk: 1, fullName: 1, email: 1, role: 1, approved: 1 });
+  }
+
+  async isUserValid(did) {
+    const count = await super.count({ did, approved: true });
+    return count > 0;
+  }
+
+  async isConnectedAccount(did) {
+    const count = await this.connectedAccount.count({ did });
+    return count > 0;
+  }
+
+  async isPassportValid(passportId) {
+    const count = await this.passport.count({ id: passportId, status: PASSPORT_STATUS.VALID });
+    return count > 0;
   }
 }