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

package/lib/states/node.js

@@ -4,22 +4,25 @@ const omit = require('lodash/omit');
 const isEmpty = require('lodash/isEmpty');
 const security = require('@abtnode/util/lib/security');
 const { isFromPublicKey } = require('@arcblock/did');
-const logger = require('@abtnode/logger')('@abtnode/core:node');
 const { NODE_MODES, DISK_ALERT_THRESHOLD_PERCENT, EVENTS, SERVER_STATUS } = require('@abtnode/constant');
+// const logger = require('@abtnode/logger')('@abtnode/core:node');
 
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
 const { get: getDefaultConfigs } = require('../util/default-node-config');
 
+/**
+ * @extends BaseState<import('@abtnode/models').ServerState>
+ */
 class NodeState extends BaseState {
   /**
    * Creates an instance of NodeState.
-   * @param {string} baseDir
+   * @param {object} model
    * @param {object} config
    * @memberof NodeState
    */
-  constructor(baseDir, config = {}, dataDirs = {}, notification) {
-    super(baseDir, { filename: 'node.db', ...config });
+  constructor(model, config = {}, dataDirs = {}, notification) {
+    super(model, config);
 
     // Initialize the store
     if (!config.nodeSk) {
@@ -37,14 +40,6 @@ class NodeState extends BaseState {
 
     this.dataDirs = dataDirs;
     this.notification = notification;
-
-    this.onReady(() => {
-      this.ensureIndex({ fieldName: 'did', unique: true }, (err) => {
-        if (err) {
-          console.error('Failed to ensure unique index', err);
-        }
-      });
-    });
   }
 
   isInitialized(doc) {
@@ -60,113 +55,89 @@ class NodeState extends BaseState {
    * @returns {object} Node document json
    * @memberof NodeState
    */
-  read() {
-    return new Promise((resolve, reject) => {
-      const { nodeDid, dek } = this.config;
-      this.findOne({ did: nodeDid }, (err, record) => {
-        if (err) {
-          // eslint-disable-next-line no-console
-          console.error(err);
-          return reject(err);
-        }
+  async read() {
+    const { nodeDid, dek } = this.config;
 
-        if (record) {
-          if (dek) {
-            record.sk = security.decrypt(record.sk, record.did, dek);
-          }
+    let doc = await this.findOne({ did: nodeDid });
+    if (doc) {
+      if (dek) {
+        doc.sk = security.decrypt(doc.sk, doc.did, dek);
+      }
 
-          return resolve(record);
-        }
+      return doc;
+    }
 
-        const {
-          name,
-          description,
-          nodeSk,
-          nodePk,
-          nodeOwner,
-          port,
-          version,
-          routing = { provider: 'default' },
-          docker,
-          mode,
-          runtimeConfig,
-          ownerNft,
-          launcher,
-          didRegistry,
-          didDomain,
-          enablePassportIssuance = true,
-          trustedPassports = [],
-          webWalletUrl,
-        } = this.config;
-
-        if (nodeOwner && !validateOwner(nodeOwner)) {
-          return reject(new Error('Node owner is invalid'));
-        }
+    const {
+      name,
+      description,
+      nodeSk,
+      nodePk,
+      nodeOwner,
+      port,
+      version,
+      routing = { provider: 'default' },
+      docker,
+      mode,
+      runtimeConfig,
+      ownerNft,
+      launcher,
+      didRegistry,
+      didDomain,
+      enablePassportIssuance = true,
+      trustedPassports = [],
+      webWalletUrl,
+    } = this.config;
+
+    if (nodeOwner && !validateOwner(nodeOwner)) {
+      throw new Error('Node owner is invalid');
+    }
 
-        const initialized = this.isInitialized({ nodeOwner, enablePassportIssuance, trustedPassports });
-
-        return getDefaultConfigs()
-          .then((defaultConfigs) =>
-            this.insert(
-              {
-                ...(defaultConfigs || {}),
-                name,
-                description,
-                pk: nodePk,
-                sk: dek ? security.encrypt(nodeSk, nodeDid, dek) : nodeSk,
-                did: nodeDid,
-                initialized,
-                version,
-                nodeOwner: nodeOwner || undefined,
-                port,
-                initializedAt: initialized ? new Date() : undefined,
-                startedAt: undefined,
-                routing,
-                docker,
-                mode,
-                enableWelcomePage: mode !== NODE_MODES.SERVERLESS,
-                enableBetaRelease: false,
-                runtimeConfig,
-                ownerNft,
-                diskAlertThreshold: DISK_ALERT_THRESHOLD_PERCENT,
-                launcher: launcher || undefined,
-                didRegistry,
-                didDomain,
-                enablePassportIssuance,
-                trustedPassports,
-                customBlockletNumber: 0,
-                webWalletUrl,
-              },
-              async (e, data) => {
-                if (e) {
-                  logger.error('create error', { error: e });
-                  if (e.message.indexOf('violates the unique constraint') > 0) {
-                    return resolve(await this.read());
-                  }
-
-                  return reject(e);
-                }
-
-                logger.info('create', { data });
-                if (dek) {
-                  data.sk = security.decrypt(data.sk, data.did, dek);
-                }
-
-                return resolve(data);
-              }
-            )
-          ) // eslint-disable-line
-          .catch(reject);
-      });
+    const initialized = this.isInitialized({ nodeOwner, enablePassportIssuance, trustedPassports });
+    const defaultConfigs = await getDefaultConfigs();
+
+    doc = await this.insert({
+      ...(defaultConfigs || {}),
+      name,
+      description,
+      pk: nodePk,
+      sk: dek ? security.encrypt(nodeSk, nodeDid, dek) : nodeSk,
+      did: nodeDid,
+      initialized,
+      version,
+      nodeOwner: nodeOwner || null,
+      port,
+      initializedAt: initialized ? new Date() : null,
+      startedAt: null,
+      routing,
+      docker,
+      mode,
+      enableWelcomePage: mode !== NODE_MODES.SERVERLESS,
+      enableBetaRelease: false,
+      runtimeConfig,
+      ownerNft,
+      diskAlertThreshold: DISK_ALERT_THRESHOLD_PERCENT,
+      launcher: launcher || null,
+      didRegistry,
+      didDomain,
+      enablePassportIssuance,
+      trustedPassports,
+      customBlockletNumber: 0,
+      webWalletUrl,
     });
+
+    if (dek) {
+      doc.sk = security.decrypt(doc.sk, doc.did, dek);
+    }
+
+    return doc;
   }
 
   // FIXME: 这个接口比较危险，可能会修改一些本不应该修改的字段，后续需要考虑改进
   async updateNodeInfo(entity = {}) {
-    const record = await this.read();
-    const updateResult = await this.update(record._id, { $set: omit(entity, ['ownerNft', 'sk']) });
-    this.emit(EVENTS.NODE_UPDATED, updateResult, record);
-    return updateResult;
+    const old = await this.read();
+    const doc = await this.update({ $set: omit(entity, ['ownerNft', 'sk']) });
+    this.emit(EVENTS.NODE_UPDATED, doc, old);
+    return doc;
   }
 
   async updateNodeRouting(entity = {}) {
@@ -191,27 +162,26 @@ class NodeState extends BaseState {
           updates.previousMode = '';
         }
 
-        return this.update(doc._id, { $set: updates });
+        return this.update({ $set: updates });
       }
 
       return doc;
     });
   }
 
-  async addOwner(owner, doc) {
+  async addOwner(owner) {
     const initialized = this.isInitialized({ nodeOwner: owner });
-
     if (this.notification && typeof this.notification.setDefaultReceiver === 'function') {
       this.notification.setDefaultReceiver(owner.did);
     }
 
-    const updateResult = await this.update(doc._id, {
+    const updated = await this.update({
       $set: { nodeOwner: owner, initialized, initializedAt: initialized ? new Date() : null },
     });
 
-    this.emit(EVENTS.NODE_ADDED_OWNER, updateResult);
+    this.emit(EVENTS.NODE_ADDED_OWNER, updated);
 
-    return updateResult;
+    return updated;
   }
 
   async updateNodeOwner({ nodeOwner, ownerNft }) {
@@ -219,10 +189,7 @@ class NodeState extends BaseState {
       throw new Error('Node owner is invalid');
     }
 
-    const doc = await this.read();
-
     const initialized = this.isInitialized({ nodeOwner });
-
     if (this.notification && typeof this.notification.setDefaultReceiver === 'function') {
       this.notification.setDefaultReceiver(nodeOwner.did);
     }
@@ -232,13 +199,9 @@ class NodeState extends BaseState {
       entities.ownerNft = ownerNft;
     }
 
-    const updateResult = await this.update(doc._id, {
-      $set: entities,
-    });
-
-    this.emit(EVENTS.NODE_ADDED_OWNER, updateResult);
-
-    return updateResult;
+    const updated = await this.update({ $set: entities });
+    this.emit(EVENTS.NODE_ADDED_OWNER, updated);
+    return updated;
   }
 
   async updateNftHolder(holder) {
@@ -246,11 +209,7 @@ class NodeState extends BaseState {
       throw new Error('NFT holder can not be empty');
     }
 
-    const doc = await this.read();
-
-    return this.update(doc._id, {
-      $set: { 'ownerNft.holder': holder },
-    });
+    return this.update({ $set: { 'ownerNft.holder': holder } });
   }
 
   async enterMode(mode) {
@@ -305,21 +264,19 @@ class NodeState extends BaseState {
 
   // deprecated
   async increaseCustomBlockletNumber() {
-    const { _id, customBlockletNumber = 0 } = await this.read();
+    const { customBlockletNumber = 0 } = await this.read();
     const num = customBlockletNumber + 1;
-    await this.update(_id, { $set: { customBlockletNumber: num } });
+    await this.update({ $set: { customBlockletNumber: num } });
     return num;
   }
 
   async updateGateway(gateway) {
-    const [, nodeInfo] = await this.update(
-      {},
-      { $set: { 'routing.requestLimit': gateway.requestLimit, 'routing.cacheEnabled': gateway.cacheEnabled } }
-    );
-
-    this.emit(EVENTS.RELOAD_GATEWAY, nodeInfo);
+    const doc = await this.update({
+      $set: { 'routing.requestLimit': gateway.requestLimit, 'routing.cacheEnabled': gateway.cacheEnabled },
+    });
 
-    return nodeInfo.routing;
+    this.emit(EVENTS.RELOAD_GATEWAY, doc);
+    return doc.routing;
   }
 
   async updateStatus(status) {
@@ -327,16 +284,18 @@ class NodeState extends BaseState {
       throw new Error('status is invalid');
     }
 
-    const record = await this.read();
-    await this.update(record._id, { $set: { status } });
-
-    record.status = status;
-    return record;
+    return this.update({ $set: { status } });
   }
 
   async resetStatus() {
     return this.updateStatus(SERVER_STATUS.RUNNING);
   }
+
+  async update(updates) {
+    await this.read();
+    const [, [updated]] = await super.update({ did: this.config.nodeDid }, updates);
+    return updated;
+  }
 }
 
 module.exports = NodeState;

package/lib/states/notification.js

@@ -3,6 +3,9 @@ const { EVENTS } = require('@abtnode/constant');
 
 const BaseState = require('./base');
 
+/**
+ * @extends BaseState<import('@abtnode/models').NotificationState>
+ */
 class NotificationState extends BaseState {
   constructor(baseDir, config = {}) {
     super(baseDir, { filename: 'notification.db', ...config });
@@ -19,43 +22,30 @@ class NotificationState extends BaseState {
     this.defaultReceiver = receiver;
   }
 
-  create(payload) {
+  async create(payload) {
     ['title', 'description'].forEach((x) => {
       if (!payload[x]) {
         throw new Error(`Invalid notification payload: ${x} is required`);
       }
     });
 
-    return new Promise((resolve, reject) => {
-      this.insert(
-        {
-          sender: payload.sender || this.defaultSender,
-          receiver: payload.receiver || this.defaultReceiver,
-          title: payload.title,
-          description: payload.description,
-          action: payload.action || '',
-          entityType: payload.entityType || '',
-          entityId: payload.entityId || '',
-          severity: payload.severity || 'info',
-          read: false,
-        },
-        (e, data) => {
-          if (e) {
-            logger.error('create error', { error: e });
-            return reject(e);
-          }
-
-          logger.info('create', { data });
-          this.emit(EVENTS.NOTIFICATION_CREATE, data);
-          return resolve(data);
-        }
-      );
+    const doc = await this.insert({
+      sender: payload.sender || this.defaultSender,
+      receiver: payload.receiver || this.defaultReceiver,
+      title: payload.title,
+      description: payload.description,
+      action: payload.action || '',
+      entityType: payload.entityType || '',
+      entityId: payload.entityId || '',
+      severity: payload.severity || 'info',
+      read: false,
     });
+    this.emit(EVENTS.NOTIFICATION_CREATE, doc);
+    return doc;
   }
 
   async findPaginated({ read, paging } = {}) {
     const conditions = {};
-
     if (typeof read === 'boolean') {
       conditions.read = read;
     }
@@ -67,26 +57,14 @@ class NotificationState extends BaseState {
   async read({ id }, context) {
     const idList = id.split(',').map((x) => x.trim());
     logger.info('mark notification as read', { idList });
-
-    const [numAffected] = await this.update(
-      { _id: { $in: idList } },
-      { $set: { read: true } },
-      { multi: true, upsert: false, returnUpdatedDocs: false }
-    );
-
+    const [numAffected] = await this.update({ id: { $in: idList } }, { $set: { read: true } });
     return numAffected;
   }
 
   // eslint-disable-next-line no-unused-vars
   async unread({ id }, context) {
     const idList = Array.isArray(id) ? id : [id];
-
-    const [numAffected] = await this.update(
-      { _id: { $in: idList } },
-      { $set: { read: false } },
-      { multi: true, upsert: false, returnUpdatedDocs: false }
-    );
-
+    const [numAffected] = await this.update({ id: { $in: idList } }, { $set: { read: false } });
     return numAffected;
   }
 }

package/lib/states/passport.js

@@ -0,0 +1,8 @@
+const BaseState = require('./base');
+
+/**
+ * @extends BaseState<import('@abtnode/models').PassportState>
+ */
+class Passport extends BaseState {}
+
+module.exports = Passport;

package/lib/states/session.js

@@ -1,68 +1,52 @@
-const logger = require('@abtnode/logger')('@abtnode/core:states:session');
+const omit = require('lodash/omit');
 const BaseState = require('./base');
 
 /**
  * This db is used to save session data generated in a http session. the session is NOT user auth session.
+ * @extends BaseState<import('@abtnode/models').SessionState>
  */
 class SessionState extends BaseState {
-  constructor(baseDir, config = {}) {
-    super(baseDir, { filename: 'session.db', ...config });
-
-    this.onReady(() => {
-      this.ensureIndex({ fieldName: 'createdAt' }, (error) => {
-        if (error) {
-          logger.error('ensure createdAt index failed', { error });
-        }
-      });
-
-      this.ensureIndex({ fieldName: 'expireDate', expireAfterSeconds: 0 }, (error) => {
-        if (error) {
-          logger.error('ensure expireDate index failed', { error });
-        }
-      });
-    });
-  }
-
-  async start(initialData) {
-    const { _id, ...data } = await this.insert(initialData);
-    return { id: _id, ...data };
+  /**
+   * type is used to group sessions
+   * key is used to identify sessions
+   */
+  async start({ type, key, ...data }) {
+    const doc = await this.insert({ type, key, __data: data });
+    return this._format(doc);
   }
 
-  async update(id, data) {
-    const exist = await this.findOne({ _id: id });
-
-    if (!exist) {
+  async update(id, updates) {
+    const doc = await this.findOne({ id });
+    if (!doc) {
       throw new Error(`Session does not exist: ${id}`);
     }
 
-    // eslint-disable-next-line no-underscore-dangle
-    delete exist._id;
-    await super.update({ _id: id }, { $set: { ...exist, ...data } }, { multi: false, upsert: false });
-
-    return { id, ...exist, ...data };
+    await super.update({ id }, { __data: { ...doc.__data, ...updates } });
+    return this._format(doc, updates);
   }
 
   async read(id) {
-    const item = await this.findOne({ _id: id });
-    if (item) {
-      // eslint-disable-next-line no-underscore-dangle
-      item.id = item._id;
-    }
-
-    return item;
+    const doc = await this.findOne({ id });
+    return this._format(doc);
   }
 
   async end(id) {
-    const data = await this.findOne({ _id: id });
-
-    if (!data) {
+    const doc = await this.findOne({ id });
+    if (!doc) {
       throw new Error(`Session does not exist: ${id}`);
     }
 
-    await this.remove({ _id: id });
+    await this.remove({ id });
+    return this._format(doc);
+  }
+
+  async find(...args) {
+    const docs = await super.find(...args);
+    return docs.map(this._format);
+  }
 
-    data.id = id;
-    return data;
+  _format(doc, extra = {}) {
+    return doc ? omit({ ...doc, ...doc.__data, ...extra }, ['__data']) : doc;
   }
 }
 

package/lib/states/site.js

@@ -1,5 +1,4 @@
 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');
@@ -14,24 +13,26 @@ const { validateUpdateDomainAliases } = require('../validators/router');
 //   corsAllowedOrigins: Array<string>;
 // };
 
+/**
+ * FIXME: @wangshijun some functions may not be performant
+ * @extends BaseState<import('@abtnode/models').SiteState>
+ */
 class SiteState extends BaseState {
-  constructor(baseDir, config = {}) {
-    super(baseDir, { filename: 'routing_rule.db', ...config });
-  }
-
   async add(site) {
     const result = await this.insert(site);
-
-    const tmpSite = SiteState.renameIdFiledName(result);
-    logger.info('site created', { site: tmpSite });
-    return tmpSite;
+    logger.info('site created', { site: result });
+    return result;
   }
 
   async addRuleToSite(id, rule) {
-    const addedCount = await this.update({ _id: id }, { $addToSet: { rules: rule } });
+    const { rules } = await this.findOne({ id });
+    if (rules.indexOf(rule) === -1) {
+      const [addedCount] = await this.update({ id }, { $set: { rules: [...rules, rule] } });
+      logger.info('added rule to site', { count: addedCount });
+      return addedCount;
+    }
 
-    logger.info('added rule to site', { count: addedCount });
-    return addedCount;
+    return 0;
   }
 
   async getSites(...args) {
@@ -46,48 +47,41 @@ class SiteState extends BaseState {
   }
 
   async getSitesByBlocklet(did) {
-    const rules = await this.find({ 'rules.to.did': did });
-    return SiteState.renameIdFiledName(rules);
+    const sites = await this.getSites();
+    return sites.filter((x) => x.rules.some((r) => r.to?.did === did));
   }
 
-  async getRuleById(id) {
-    const site = await this.findOne({ 'rules.id': id });
-    if (!site) {
-      return null;
+  async getSiteByRuleId(id, ruleId) {
+    const site = await this.findOne({ id });
+    if (site && site.rules.some((r) => r.id === ruleId)) {
+      return site;
     }
 
-    return site.rules.find((x) => x.id === id);
+    return null;
   }
 
-  async findOne(...args) {
-    const site = await super.findOne(...args);
+  async getRuleById(id) {
+    const sites = await this.getSites();
+    const site = sites.find((x) => x.rules.some((r) => r.id === id));
     if (!site) {
-      return site;
+      return null;
     }
 
-    return BaseState.renameIdFiledName(site);
+    return site.rules.find((x) => x.id === id);
   }
 
   async domainExists(domain) {
-    const count = await this.count({
-      $or: [{ domain }, { domainAliases: domain }, { 'domainAliases.value': domain }],
-    });
-
-    return count > 0;
+    const sites = await this.getSites();
+    return sites.some((x) => x.domain === domain || x.domainAliases.some((y) => y.value === domain));
   }
 
-  async findOneByDomain(domain) {
-    // eslint-disable-next-line no-param-reassign
-    domain = toSlotDomain(domain);
-    return this.findOne({
-      $or: [{ domain }, { domainAliases: domain }, { 'domainAliases.value': domain }],
-    });
+  async findByDomainAlias(domain) {
+    const sites = await this.getSites();
+    return sites.find((x) => x.domainAliases.some((y) => y.value === domain));
   }
 
   async findOneByBlocklet(did) {
-    const result = await this.findOne({ domain: getBlockletDomainGroupName(did) });
-
-    return BaseState.renameIdFiledName(result);
+    return this.findOne({ domain: getBlockletDomainGroupName(did) });
   }
 
   async getBlockletDomains(did) {
@@ -97,8 +91,7 @@ class SiteState extends BaseState {
 
   async updateDomainAliasList(id, domainAliases) {
     await validateUpdateDomainAliases(domainAliases);
-
-    return super.update({ _id: id }, { $set: { domainAliases } });
+    return super.update({ id }, { $set: { domainAliases } });
   }
 }