@abtnode/core 1.15.17 → 1.16.0-beta-b16cb035

package/lib/states/site.js

@@ -1,22 +1,34 @@
 const logger = require('@abtnode/logger')('@abtnode/core:states:site');
+const { toSlotDomain } = require('@abtnode/router-provider/lib/util');
 
 const BaseState = require('./base');
+const { getBlockletDomainGroupName } = require('../util/router');
+const { validateUpdateDomainAliases } = require('../validators/router');
+
+// type Site = {
+//   id: string;
+//   domain: string;
+//   domainAliases: Array<{value: string, isProtected: boolean}>;
+//   isProtected: boolean;
+//   rules: Array<Rule>;
+//   corsAllowedOrigins: Array<string>;
+// };
 
 class SiteState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'routing_rule.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'routing_rule.db', ...config });
   }
 
-  async add(rule) {
-    const result = await this.asyncDB.insert(rule);
+  async add(site) {
+    const result = await this.insert(site);
 
-    const tmpRule = SiteState.renameIdFiledName(result);
-    logger.info('rule created', { rule: tmpRule });
-    return tmpRule;
+    const tmpSite = SiteState.renameIdFiledName(result);
+    logger.info('site created', { site: tmpSite });
+    return tmpSite;
   }
 
   async addRuleToSite(id, rule) {
-    const addedCount = await this.asyncDB.update({ _id: id }, { $addToSet: { rules: rule } });
+    const addedCount = await this.update({ _id: id }, { $addToSet: { rules: rule } });
 
     logger.info('added rule to site', { count: addedCount });
     return addedCount;
@@ -25,21 +37,21 @@ class SiteState extends BaseState {
   async getSites(...args) {
     let result = null;
     if (args.length === 0) {
-      result = await this.asyncDB.find({});
+      result = await this.find({});
     } else {
-      result = await this.asyncDB.find(...args);
+      result = await this.find(...args);
     }
 
     return SiteState.renameIdFiledName(result);
   }
 
   async getSitesByBlocklet(did) {
-    const rules = await this.asyncDB.find({ 'rules.to.did': did });
+    const rules = await this.find({ 'rules.to.did': did });
     return SiteState.renameIdFiledName(rules);
   }
 
   async getRuleById(id) {
-    const site = await this.asyncDB.findOne({ 'rules.id': id });
+    const site = await this.findOne({ 'rules.id': id });
     if (!site) {
       return null;
     }
@@ -47,20 +59,8 @@ class SiteState extends BaseState {
     return site.rules.find((x) => x.id === id);
   }
 
-  async update(...args) {
-    return this.asyncDB.update(...args);
-  }
-
-  async count(...args) {
-    return this.asyncDB.count(...args);
-  }
-
-  async remove(...args) {
-    return this.asyncDB.remove(...args);
-  }
-
   async findOne(...args) {
-    const site = await this.asyncDB.findOne(...args);
+    const site = await super.findOne(...args);
     if (!site) {
       return site;
     }
@@ -75,6 +75,31 @@ class SiteState extends BaseState {
 
     return count > 0;
   }
+
+  async findOneByDomain(domain) {
+    // eslint-disable-next-line no-param-reassign
+    domain = toSlotDomain(domain);
+    return this.findOne({
+      $or: [{ domain }, { domainAliases: domain }, { 'domainAliases.value': domain }],
+    });
+  }
+
+  async findOneByBlocklet(did) {
+    const result = await this.findOne({ domain: getBlockletDomainGroupName(did) });
+
+    return BaseState.renameIdFiledName(result);
+  }
+
+  async getBlockletDomains(did) {
+    const site = await this.findOneByBlocklet(did);
+    return (site?.domainAliases || []).map((x) => x.value).filter(Boolean);
+  }
+
+  async updateDomainAliasList(id, domainAliases) {
+    await validateUpdateDomainAliases(domainAliases);
+
+    return super.update({ _id: id }, { $set: { domainAliases } });
+  }
 }
 
 module.exports = SiteState;

package/lib/states/user.js

@@ -1,20 +1,24 @@
+const pickBy = require('lodash/pickBy');
+const escapeStringRegexp = require('escape-string-regexp');
+
 const logger = require('@abtnode/logger')('@abtnode/core:states:user');
+const { isValid } = require('@arcblock/did');
 const { PASSPORT_STATUS } = require('@abtnode/constant');
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
 
-const fixPassports = (doc) => {
-  doc.passports = (doc.passports || []).filter((x) => x.id);
-};
+const isNullOrUndefined = (x) => x === undefined || x === null;
 
 class User extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'user.db', ...options });
-
-    this.db.ensureIndex({ fieldName: 'did', unique: true }, (error) => {
-      if (error) {
-        logger.error('ensure index failed', { error });
-      }
+  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 });
+        }
+      });
     });
   }
 
@@ -85,21 +89,71 @@ class User extends BaseState {
     return doc;
   }
 
-  async getUsers() {
-    const docs = await super.find();
-    if (docs) {
-      docs.forEach(fixPassports); // backward compatible
+  async getUsers({ query, sort, paging: inputPaging } = {}) {
+    const { approved, role, search } = query || {};
+
+    // make query param
+    const queryParam = {};
+
+    if (!isNullOrUndefined(approved)) {
+      queryParam.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;
+      } else {
+        const reg = new RegExp(escapeStringRegexp(search), 'i');
+
+        queryParam.fullName = { $regex: reg };
+      }
+    }
+
+    if (role && role !== '$all') {
+      if (role === '$none') {
+        queryParam.passports = { $size: 0 };
+      } else {
+        queryParam.passports = { $elemMatch: { name: role, status: PASSPORT_STATUS.VALID } };
+      }
+    }
+
+    const sortParam = pickBy(sort, (x) => !isNullOrUndefined(x));
+
+    if (!Object.keys(sortParam).length) {
+      sortParam.createdAt = -1;
     }
 
-    return docs;
+    // get data
+    const { list, paging } = await this.paginate(queryParam, sortParam, inputPaging);
+
+    return {
+      list,
+      paging,
+    };
   }
 
-  async getUser(did) {
-    const doc = await super.findOne({ did });
-    if (doc) {
-      fixPassports(doc); // backward compatible
+  async getUsersByDids({ dids, query } = {}) {
+    const { approved } = query || {};
+    const didList = dids || [];
+
+    const queryParam = {
+      did: { $in: didList },
+    };
+
+    if (!isNullOrUndefined(approved)) {
+      queryParam.approved = !!approved;
     }
 
+    // get data
+    return this.find(queryParam);
+  }
+
+  async getUser(did) {
+    const doc = await this.findOne({ did });
     return doc;
   }
 
@@ -109,7 +163,7 @@ class User extends BaseState {
    * @param {string} status passport status
    */
   async _setPassportStatusById({ did, id, status } = {}) {
-    const exist = await super.findOne({ did });
+    const exist = await this.findOne({ did });
 
     if (!exist) {
       throw new Error('did does not exist');

package/lib/states/webhook.js

@@ -4,11 +4,11 @@ const BaseState = require('./base');
 const { validateWebhook } = require('../validators/webhook');
 
 class WebhookState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'webhook.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'webhook.db', ...config });
   }
 
-  async create(info) {
+  async create(info, { mock } = {}) {
     const { type, params } = info;
     const filterParams = params.map((item) => {
       const data = {
@@ -26,7 +26,11 @@ class WebhookState extends BaseState {
 
     await validateWebhook(data);
 
-    const webhook = await this.asyncDB.insert(data);
+    if (mock) {
+      return data;
+    }
+
+    const webhook = await this.insert(data);
     return webhook;
   }
 
@@ -42,7 +46,7 @@ class WebhookState extends BaseState {
       throw new Error('webhookId should not be empty');
     }
     const webhook = await this.findOne(id);
-    const num = await this.asyncDB.remove({ _id: id });
+    const num = await this.remove({ _id: id });
     if (num <= 0) {
       throw new Error(`${id} does not exist`);
     }
@@ -52,7 +56,7 @@ class WebhookState extends BaseState {
 
   async findOne(id) {
     try {
-      const webhook = await this.asyncDB.findOne({ _id: id });
+      const webhook = await super.findOne({ _id: id });
 
       return webhook;
     } catch (error) {

package/lib/team/manager.js

@@ -5,11 +5,14 @@ const path = require('path');
 const { EventEmitter } = require('events');
 const upperFirst = require('lodash/upperFirst');
 const get = require('lodash/get');
+const pick = require('lodash/pick');
 
 const { createRBAC, MemoryStorage, NedbStorage } = require('@abtnode/rbac');
 const logger = require('@abtnode/logger')('@abtnode/core:team:manager');
 const { ROLES, RBAC_CONFIG } = require('@abtnode/constant');
+const { BlockletEvents } = require('@blocklet/constant');
 const Lock = require('@abtnode/util/lib/lock');
+const sleep = require('@abtnode/util/lib/sleep');
 const UserState = require('../states/user');
 const SessionState = require('../states/session');
 
@@ -17,6 +20,23 @@ const { isCLI } = require('../util');
 
 const rbacCreationLock = new Lock('rbac-creation-lock');
 
+const closeDatabase = async (db) =>
+  new Promise((resolve, reject) => {
+    if (!db) {
+      resolve(true);
+      return;
+    }
+
+    db.closeDatabase((err) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+
+      resolve(true);
+    });
+  });
+
 class TeamManager extends EventEmitter {
   constructor({ nodeDid, dataDirs, states }) {
     super();
@@ -48,10 +68,6 @@ class TeamManager extends EventEmitter {
       });
     });
 
-    this.states.blocklet.on('remove', ({ meta: { did } }) => {
-      this.cache[did] = null;
-    });
-
     // init blocklet
     this.states.blocklet
       .getBlocklets()
@@ -96,7 +112,7 @@ class TeamManager extends EventEmitter {
 
   async getUserState(did) {
     // validate exist
-    if (!this.isNodeTeam(did) && !(await this.states.blocklet.getBlocklet(did))) {
+    if (!this.isNodeTeam(did) && !(await this.states.blocklet.hasBlocklet(did))) {
       logger.error('Did does not exist', { action: 'getUserState', did });
       throw new Error(`Did does not exist: ${did}`);
     }
@@ -135,7 +151,7 @@ class TeamManager extends EventEmitter {
 
   async getSessionState(did) {
     // validate exist
-    if (!this.isNodeTeam(did) && !(await this.states.blocklet.getBlocklet(did))) {
+    if (!this.isNodeTeam(did) && !(await this.states.blocklet.hasBlocklet(did))) {
       logger.error('Did does not exist', { action: 'getSessionState', did });
       throw new Error(`Did does not exist: ${did}`);
     }
@@ -174,7 +190,7 @@ class TeamManager extends EventEmitter {
     logger.info('get rbac', { did });
 
     // validate exist
-    if (!this.isNodeTeam(did) && !(await this.states.blocklet.getBlocklet(did))) {
+    if (!this.isNodeTeam(did) && !(await this.states.blocklet.hasBlocklet(did))) {
       logger.error('Did does not exist', { action: 'getRBAC', did });
       throw new Error(`Did does not exist: ${did}`);
     }
@@ -234,6 +250,14 @@ class TeamManager extends EventEmitter {
     return this.states.blockletExtras.setSettings(did, { trustedPassports });
   }
 
+  async configWhoCanAccess(did, value) {
+    if (this.isNodeTeam(did)) {
+      throw new Error('Cannot be node did');
+    }
+
+    return this.states.blockletExtras.setSettings(did, { whoCanAccess: value });
+  }
+
   async configPassportIssuance(did, enable) {
     const enablePassportIssuance = enable;
     if (this.isNodeTeam(did)) {
@@ -259,6 +283,99 @@ class TeamManager extends EventEmitter {
     }
   }
 
+  async getStoreList(did) {
+    if (this.isNodeTeam(did)) {
+      const nodeInfo = await this.states.node.read();
+      return nodeInfo.blockletRegistryList || [];
+    }
+
+    const settings = await this.states.blockletExtras.getSettings(did);
+    return get(settings, 'storeList', []) || [];
+  }
+
+  async updateStoreList(did, list) {
+    if (this.isNodeTeam(did)) {
+      await this.states.node.updateNodeInfo({ blockletRegistryList: list });
+      return;
+    }
+
+    await this.states.blockletExtras.setSettings(did, { storeList: list });
+    this.emit(BlockletEvents.storeChange, { meta: { did } });
+  }
+
+  async getOwner(did) {
+    let owner;
+    if (this.isNodeTeam(did)) {
+      const nodeInfo = await this.states.node.read();
+      owner = get(nodeInfo, 'nodeOwner');
+    } else {
+      const settings = await this.states.blockletExtras.getSettings(did);
+      owner = get(settings, 'owner');
+    }
+
+    return owner;
+  }
+
+  async getRoles(did) {
+    const rbac = await this.getRBAC(did);
+
+    const roles = await rbac.getRoles();
+
+    return roles.map((d) => pick(d, ['name', 'grants', 'title', 'description']));
+  }
+
+  async initTeam(did) {
+    if (!did) {
+      logger.error('initTeam: did does not exist');
+      return;
+    }
+
+    logger.info('initTeam', { did });
+
+    const rbac = await this.getRBAC(did);
+    const user = await this.getUserState(did);
+    const session = await this.getSessionState(did);
+
+    this.cache[did] = {
+      rbac,
+      user,
+      session,
+    };
+  }
+
+  async deleteTeam(did, { closeDatabase: closeDB = true } = {}) {
+    if (!did) {
+      logger.error('deleteTeam: did does not exist');
+      return;
+    }
+
+    logger.info('deleteTeam', { did, closeDB });
+
+    if (closeDB && this.cache[did]) {
+      try {
+        if (this.cache[did].rbac) {
+          await closeDatabase(this.cache[did].rbac.storage.db);
+        }
+
+        if (this.cache[did].user) {
+          await closeDatabase(this.cache[did].user.db);
+        }
+
+        if (this.cache[did].session) {
+          await closeDatabase(this.cache[did].session.db);
+        }
+
+        // NOTICE: wait for nedb to finish closeDatabase
+        const timeout = process.env.NODE_ENV !== 'test' ? 2000 : 200;
+        await sleep(timeout);
+      } catch (error) {
+        logger.error('Failed to close database', { did, error });
+      }
+    }
+
+    this.cache[did] = null;
+  }
+
   // =======
   // Private
   // =======