@abtnode/core 1.16.11-beta-0ae58a71 → 1.16.11-beta-f74663ac

package/lib/states/blocklet.js

@@ -2,6 +2,7 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable function-paren-newline */
 /* eslint-disable no-underscore-dangle */
+const pick = require('lodash/pick');
 const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
 const cloneDeep = require('lodash/cloneDeep');
@@ -13,17 +14,23 @@ const {
   getDisplayName,
   forEachBlocklet,
   forEachBlockletSync,
-  forEachChildSync,
+  forEachComponentV2Sync,
   getBlockletServices,
 } = require('@blocklet/meta/lib/util');
-const { BlockletStatus, BlockletSource, BLOCKLET_MODES, BLOCKLET_DEFAULT_PORT_NAME } = require('@blocklet/constant');
+const {
+  BlockletStatus,
+  BlockletSource,
+  BLOCKLET_MODES,
+  BLOCKLET_DEFAULT_PORT_NAME,
+  BlockletGroup,
+} = require('@blocklet/constant');
 const { APP_STRUCT_VERSION } = require('@abtnode/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:states:blocklet');
 
 const BaseState = require('./base');
 const { checkDuplicateComponents, ensureMeta } = require('../util/blocklet');
-const { validateBlockletMeta } = require('../util/blocklet');
+const { validateBlockletMeta, getBlockletStatus, shouldSkipComponent } = require('../util/blocklet');
 
 const lock = new Lock('blocklet-port-assign-lock');
 
@@ -37,6 +44,10 @@ const getExternalPortsFromMeta = (meta) =>
   (meta.interfaces || []).map((x) => x.port && x.port.external).filter(Boolean);
 
 const formatBlocklet = (blocklet, phase, dek) => {
+  if (phase === 'onRead') {
+    blocklet.status = getBlockletStatus(blocklet);
+  }
+
   forEachBlockletSync(blocklet, (b) => {
     if (b.meta) {
       fixPerson(b.meta);
@@ -273,6 +284,9 @@ class BlockletState extends BaseState {
 
     const formatted = formatBlocklet(cloneDeep(updates), 'onUpdate', this.config.dek);
     const [, [updated]] = await this.update({ id: doc.id }, { $set: formatted });
+
+    updated.status = getBlockletStatus(updated);
+
     return updated;
   }
 
@@ -480,62 +494,55 @@ class BlockletState extends BaseState {
   }
 
   /**
-   * @param {String} did blocklet did
+   * @param {Did} did blocklet did
    * @param {BlockletStatus} status blocklet status
-   *
-   * children status only different with parent before blocklet installation
-   * @param {Array<componentId>} children
+   * @param {{
+   *   componentDids?: Array<Did>
+   * }}
    */
-  async setBlockletStatus(did, status, { children } = {}) {
+  async setBlockletStatus(did, status, { componentDids } = {}) {
     if (typeof status === 'undefined') {
       throw new Error('Unsupported blocklet status');
     }
 
     const doc = await this.getBlocklet(did);
-    if (doc.status === status && !children) {
-      return formatBlocklet(doc, 'onRead', this.config.dek);
-    }
 
-    const updates = { status, startedAt: null, stoppedAt: null };
-    if (status === BlockletStatus.running) {
-      updates.startedAt = new Date();
-    }
-    if (status === BlockletStatus.installed) {
-      updates.installedAt = new Date();
+    if (doc.meta?.group === BlockletGroup.gateway && !doc.children?.length) {
+      return this.updateBlocklet(did, { status });
     }
-    if (status === BlockletStatus.stopped) {
-      updates.stoppedAt = new Date();
+
+    // for backward compatibility
+    if (!doc.structVersion && !doc.children?.length) {
+      return this.updateBlocklet(did, { status });
     }
 
     // update children status
-    forEachChildSync(doc, (child, { id }) => {
-      if (children === 'all') {
-        child.status = status;
+    forEachComponentV2Sync(doc, (component) => {
+      if (component.meta.group === BlockletGroup.gateway) {
         return;
       }
 
-      if (!children) {
-        if (
-          ![
-            BlockletStatus.waiting,
-            BlockletStatus.upgrading,
-            BlockletStatus.installing,
-            BlockletStatus.starting,
-          ].includes(status)
-        ) {
-          child.status = status;
-        }
-
+      if (shouldSkipComponent(component.meta.did, componentDids)) {
         return;
       }
 
-      if (children.includes(id)) {
-        child.status = status;
+      component.status = status;
+      if (status === BlockletStatus.running) {
+        component.startedAt = new Date();
+        component.stoppedAt = null;
+      }
+      if (status === BlockletStatus.stopped) {
+        component.startedAt = null;
+        component.stoppedAt = new Date();
       }
     });
 
-    updates.children = doc.children;
-    return this.updateBlocklet(did, updates);
+    return this.updateBlocklet(did, pick(doc, ['status', 'children']));
+  }
+
+  setInstalledAt(did) {
+    logger.info('setInstalledAt', { did });
+    return this.updateBlocklet(did, { installedAt: new Date() });
   }
 
   async fillChildrenPorts(children, { defaultPort = 0, oldChildren, returnMaxPort } = {}) {
@@ -631,7 +638,7 @@ class BlockletState extends BaseState {
     });
   }
 
-  async updateStructV1Did(did, v1Did) {
+  updateStructV1Did(did, v1Did) {
     return this.updateBlocklet(did, { structV1Did: v1Did });
   }
 }

package/lib/states/cache.js

@@ -15,7 +15,7 @@ class CacheState extends BaseState {
     return doc && doc.value;
   }
 
-  async delete(key) {
+  delete(key) {
     return this.remove({ key });
   }
 }

package/lib/states/node.js

@@ -204,7 +204,7 @@ class NodeState extends BaseState {
     return updated;
   }
 
-  async updateNftHolder(holder) {
+  updateNftHolder(holder) {
     if (!holder) {
       throw new Error('NFT holder can not be empty');
     }
@@ -242,6 +242,7 @@ class NodeState extends BaseState {
     return this.updateNodeInfo({ previousMode: '', mode: info.previousMode });
   }
 
+  // eslint-disable-next-line require-await
   async setMode(mode) {
     if (Object.values(NODE_MODES).includes(mode) === false) {
       throw new Error(`Can not update server to unsupported mode: ${mode}`);
@@ -250,9 +251,10 @@ class NodeState extends BaseState {
     return this.updateNodeInfo({ previousMode: '', mode });
   }
 
-  async getEnvironments() {
+  getEnvironments() {
     return this.read().then((info) => ({
       ABT_NODE: info.version,
+      ABT_NODE_VERSION: info.version,
       ABT_NODE_DID: info.did,
       ABT_NODE_SK: info.sk,
       ABT_NODE_PK: info.pk,
@@ -279,6 +281,7 @@ class NodeState extends BaseState {
     return doc.routing;
   }
 
+  // eslint-disable-next-line require-await
   async updateStatus(status) {
     if (!Object.values(SERVER_STATUS).includes(status)) {
       throw new Error('status is invalid');
@@ -287,6 +290,7 @@ class NodeState extends BaseState {
     return this.update({ $set: { status } });
   }
 
+  // eslint-disable-next-line require-await
   async resetStatus() {
     return this.updateStatus(SERVER_STATUS.RUNNING);
   }

package/lib/states/notification.js

@@ -44,7 +44,7 @@ class NotificationState extends BaseState {
     return doc;
   }
 
-  async findPaginated({ read, paging } = {}) {
+  findPaginated({ read, paging } = {}) {
     const conditions = {};
     if (typeof read === 'boolean') {
       conditions.read = read;

package/lib/states/routing-snapshot.js

@@ -49,7 +49,7 @@ module.exports = class RoutingSnapshot {
   init() {
     return this.timemachine
       .getLastSnapshot(true)
-      .then(async (hash) => {
+      .then((hash) => {
         if (hash) {
           return hash;
         }

package/lib/states/site.js

@@ -80,7 +80,7 @@ class SiteState extends BaseState {
     return sites.find((x) => x.domainAliases.some((y) => y.value === domain));
   }
 
-  async findOneByBlocklet(did) {
+  findOneByBlocklet(did) {
     return this.findOne({ domain: getBlockletDomainGroupName(did) });
   }
 

package/lib/states/user.js

@@ -92,22 +92,24 @@ class User extends ExtendBase {
 
     await super.update({ did }, { $set: updates });
     await Promise.all(
-      (get(updates, 'passports') || []).map((x) => this.passport.upsert({ id: x.id }, { ...x, userDid: did }))
+      (get(updates, 'passports') || [])
+        .filter((x) => x.id)
+        .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 })
-      )
+      (get(updates, 'connectedAccounts') || [])
+        .filter((x) => x.did)
+        .map((x) => this.connectedAccount.upsert({ did: x.did }, { ...x, userDid: did }))
     );
 
     return this.getUser(did);
   }
 
-  async revokePassportById({ did, id }) {
+  revokePassportById({ did, id }) {
     return this._setPassportStatusById({ did, id, status: PASSPORT_STATUS.REVOKED });
   }
 
-  async enablePassportById({ did, id }) {
+  enablePassportById({ did, id }) {
     return this._setPassportStatusById({ did, id, status: PASSPORT_STATUS.VALID });
   }
 
@@ -158,6 +160,7 @@ class User extends ExtendBase {
   /**
    * Get blocklet service user list
    */
+  // eslint-disable-next-line require-await
   async getUsers({ query, sort, paging } = {}) {
     const where = {};
     const { approved, role, search } = query || {};
@@ -199,6 +202,7 @@ class User extends ExtendBase {
     return this.paginate({ where }, sorting, paging);
   }
 
+  // eslint-disable-next-line require-await
   async getUsersByDids({ dids, query }) {
     const { approved } = query || {};
     const condition = { did: dids };
@@ -209,6 +213,7 @@ class User extends ExtendBase {
     return this.find({ where: condition });
   }
 
+  // eslint-disable-next-line require-await
   async countByPassport({ name, status = PASSPORT_STATUS.VALID }) {
     if (name === '$none') {
       return this.count({
@@ -336,6 +341,7 @@ class User extends ExtendBase {
     return { ...updated, _action: exist ? 'update' : 'add' };
   }
 
+  // eslint-disable-next-line require-await
   async getUserByDid(did) {
     return this.findOne({ did }, { did: 1, pk: 1, fullName: 1, email: 1, role: 1, approved: 1 });
   }

package/lib/team/manager.js

@@ -96,19 +96,19 @@ class TeamManager extends EventEmitter {
     };
   }
 
-  async getUserState(teamDid) {
+  getUserState(teamDid) {
     return this.getState(teamDid, 'user');
   }
 
-  async getPassportState(teamDid) {
+  getPassportState(teamDid) {
     return this.getState(teamDid, 'passport');
   }
 
-  async getConnectedAccount(teamDid) {
+  getConnectedAccountState(teamDid) {
     return this.getState(teamDid, 'connectedAccount');
   }
 
-  async getSessionState(teamDid) {
+  getSessionState(teamDid) {
     return this.getState(teamDid, 'session');
   }
 
@@ -207,7 +207,7 @@ class TeamManager extends EventEmitter {
     return this.states.blockletExtras.setSettings(metaDid, { trustedPassports });
   }
 
-  async configTrustedFactories(did, trustedFactories) {
+  configTrustedFactories(did, trustedFactories) {
     if (this.isNodeTeam(did)) {
       return this.states.node.updateNodeInfo({ trustedFactories });
     }
@@ -408,7 +408,7 @@ class TeamManager extends EventEmitter {
     }
   }
 
-  async getPid(did) {
+  getPid(did) {
     return this.isNodeTeam(did) ? did : this.states.blocklet.getBlockletMetaDid(did);
   }
 }