@abtnode/core 1.6.13 → 1.6.17

package/lib/event.js

@@ -182,7 +182,7 @@ module.exports = ({
       .catch((error) => logger.error('refresh blocklets failed on initialize the registry', { error }));
 
     // We need update router on some fields change
-    const fields = ['enableWelcomePage', 'webWalletUrl'];
+    const fields = ['enableWelcomePage', 'webWalletUrl', 'registerUrl'];
     const shouldUpdateRouter = fields.some((x) => nodeInfo[x] !== oldInfo[x]);
     if (shouldUpdateRouter) {
       handleRouting(nodeInfo).catch((err) => {

package/lib/index.js

@@ -50,6 +50,7 @@ const { toStatus, fromStatus, ensureDataDirs, getQueueConcurrencyByMem } = requi
  *   version
  *   runtimeConfig: {}
  *   autoUpgrade
+ *   registerUrl
  *   webWalletUrl
  */
 function ABTNode(options) {
@@ -196,11 +197,13 @@ function ABTNode(options) {
     // Blocklet manager
     installBlocklet: blockletManager.install.bind(blockletManager),
     installBlockletFromVc: blockletManager.installBlockletFromVc.bind(blockletManager),
+    installComponent: blockletManager.installComponent.bind(blockletManager),
     startBlocklet: blockletManager.start.bind(blockletManager),
     stopBlocklet: blockletManager.stop.bind(blockletManager),
     reloadBlocklet: blockletManager.reload.bind(blockletManager),
     restartBlocklet: blockletManager.restart.bind(blockletManager),
     deleteBlocklet: blockletManager.delete.bind(blockletManager),
+    deleteComponent: blockletManager.deleteComponent.bind(blockletManager),
     cancelDownloadBlocklet: blockletManager.cancelDownload.bind(blockletManager),
     upgradeBlocklet: blockletManager.upgrade.bind(blockletManager),
     configBlocklet: blockletManager.config.bind(blockletManager),
@@ -400,16 +403,6 @@ function ABTNode(options) {
     } else {
       // We should only respond to pm2 events when node is alive
       events.on('node.started', async () => {
-        const info = await states.node.read();
-        certManager
-          .issue({ domain: `${info.did.toLowerCase()}.${info.didDomain}` })
-          .then(() => {
-            logger.info('add issue daemon certificate job');
-          })
-          .catch((error) => {
-            logger.error('issue daemon certificate job failed', { error });
-          });
-
         pm2Events.resume();
         initCron();
       });

package/lib/migrations/1.6.17-blocklet-children.js

@@ -0,0 +1,48 @@
+/* eslint-disable no-continue */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-underscore-dangle */
+
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to update blocklet to 1.6.17...');
+  const blockletState = states.blocklet;
+
+  const blocklets = await blockletState.getBlocklets();
+  for (const blocklet of blocklets) {
+    if (!blocklet) {
+      continue;
+    }
+
+    if (!blocklet.children || !blocklet.children.length) {
+      continue;
+    }
+
+    const meta = blocklet.meta || {};
+    const { did } = meta;
+    if (!did) {
+      continue;
+    }
+
+    const children = (blocklet.children || []).map((child) => {
+      if (child.mountPoint) {
+        return child;
+      }
+
+      const config = (meta.children || []).find((x) => x.name === child.meta.name);
+
+      if (
+        config &&
+        config.mountPoints &&
+        config.mountPoints[0] &&
+        config.mountPoints[0].root &&
+        config.mountPoints[0].root.prefix
+      ) {
+        child.mountPoint = config.mountPoints[0].root.prefix;
+      }
+      printInfo(`Set mountPoint: ${child.mountPoint} to child ${child.meta.name} in ${blocklet.meta.name}`);
+
+      return child;
+    });
+
+    await blockletState.update(blocklet._id, { $set: { children } });
+  }
+};

package/lib/router/helper.js

@@ -55,6 +55,7 @@ const { getFromCache: getAccessibleExternalNodeIp } = require('../util/get-acces
 
 const Router = require('./index');
 const states = require('../states');
+const { getBlockletDomainGroupName, getDidFromDomainGroupName } = require('../util/router');
 
 /**
  * replace 888-888-888-888 with accessible ip for domain
@@ -243,6 +244,9 @@ const ensureLatestNodeInfo = async (sites = [], { withDefaultCors = true } = {})
       site.domain = DOMAIN_FOR_IP_SITE_REGEXP;
 
       if (withDefaultCors) {
+        // Allow CORS from "Install on ABT Node"
+        addCorsToSite(site, info.registerUrl);
+
         // Allow CORS from "Web Wallet"
         addCorsToSite(site, info.webWalletUrl);
       }
@@ -313,7 +317,7 @@ const ensureWellknownRule = async (sites) => {
       rules.forEach((rule) => {
         if (
           rule.to.type !== ROUTING_RULE_TYPES.BLOCKLET || // is not blocklet
-          rule.to.did !== rule.to.realDid // is a component endpoint
+          (rule.to.did !== rule.to.realDid && rule.from.pathPrefix !== '/') // is a component endpoint in sub path
         ) {
           return;
         }
@@ -353,6 +357,18 @@ const ensureCorsForWebWallet = async (sites) => {
   return sites;
 };
 
+const filterSitesForRemovedBlocklets = async (sites = []) => {
+  const blocklets = await states.blocklet.getBlocklets();
+  return sites.filter((site) => {
+    if (!site.domain.endsWith(BLOCKLET_SITE_GROUP_SUFFIX)) {
+      return true;
+    }
+
+    const did = getDidFromDomainGroupName(site.domain);
+    return blocklets.some((x) => x.meta.did === did);
+  });
+};
+
 const ensureLatestInfo = async (sites = [], { withDefaultCors = true } = {}) => {
   let result = await ensureLatestNodeInfo(sites, { withDefaultCors });
   result = await ensureWellknownRule(result);
@@ -421,7 +437,8 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
     const https = get(info, 'routing.https', true);
     const dashboardDomain = get(info, 'routing.dashboardDomain', '');
-    const certDownloadAddress = get(info, 'routing.dashboardCertDownloadAddress', '');
+    const certDownloadAddress =
+      process.env.ABT_NODE_DASHBOARD_CERT_DOWN_URL || get(info, 'routing.dashboardCertDownloadAddress', '');
     if (!https || !dashboardDomain || !certDownloadAddress) {
       return;
     }
@@ -495,9 +512,9 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       return { status: 'existed' };
     }
 
-    logger.debug('downloading certificate', { url: downloadUrl, dashboardDomain });
+    logger.debug('downloading dashboard ip-domain certificate', { url: downloadUrl, dashboardDomain });
     await updateDashboardCertificate({ checkExpire: false });
-    logger.debug('downloading certificate', { url: downloadUrl, dashboardDomain });
+    logger.debug('downloaded dashboard ip-domain certificate', { url: downloadUrl, dashboardDomain });
     return { status: 'downloaded' };
   };
 
@@ -713,7 +730,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       return `/${str}`.replace(/^\/+/, '/');
     };
 
-    const domainGroup = `${blocklet.meta.did}${BLOCKLET_SITE_GROUP_SUFFIX}`;
+    const domainGroup = getBlockletDomainGroupName(blocklet.meta.did);
 
     const pathPrefix = getPrefix(webInterface.prefix);
     const rule = {
@@ -755,13 +772,6 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         context
       );
       logger.info('add routing site', { site: domainGroup });
-      if (
-        process.env.NODE_ENV !== 'development' &&
-        process.env.NODE_ENV !== 'test' &&
-        blocklet.mode !== 'development'
-      ) {
-        await certManager.issue({ domain: didDomain });
-      }
 
       return true;
     }
@@ -1080,7 +1090,10 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     const nodeInfo = await nodeState.read();
 
     const ruleChanged = await routerManager.deleteRoutingRulesItemByDid({ did: blocklet.meta.did }, context);
-    const siteChanged = await _removeBlockletSites(blocklet, nodeInfo, context);
+    let siteChanged;
+    if (!context.keepRouting) {
+      siteChanged = await _removeBlockletSites(blocklet, nodeInfo, context);
+    }
 
     return ruleChanged || siteChanged;
   };
@@ -1140,6 +1153,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
           try {
             const info = await nodeState.read();
             let { sites } = await readRoutingSites();
+            sites = await filterSitesForRemovedBlocklets(sites);
             sites = await ensureLatestInfo(sites);
             sites = await ensureAuthService(sites, blockletManager);
             sites = await ensureServiceRule(sites);

package/lib/router/manager.js

@@ -27,6 +27,7 @@ const {
   BLOCKLET_BUNDLE_FOLDER,
   BLOCKLET_DYNAMIC_PATH_PREFIX,
   BLOCKLET_INTERFACE_TYPE_WEB,
+  BlockletGroup,
 } = require('@blocklet/meta/lib/constants');
 
 const {
@@ -37,6 +38,7 @@ const {
   validateUpdateSite,
 } = require('../validators/router');
 const { getProviderFromNodeInfo, findInterfaceByName, isCLI, findInterfacePortByName } = require('../util');
+const { findWebInterface } = require('../util/blocklet');
 const { attachInterfaceUrls, ensureLatestInfo } = require('./helper');
 const Router = require('./index');
 const states = require('../states');
@@ -186,19 +188,37 @@ class RouterManager extends EventEmitter {
     return dbSite;
   }
 
-  async addDomainAlias({ id, domainAlias }, context = {}) {
+  async addDomainAlias({ id, domainAlias, force }, context = {}) {
     await validateAddDomainAlias(domainAlias, context);
     const dbSite = await states.site.findOne({ _id: id });
     if (!dbSite) {
       throw new Error(`site ${id} does not exist`);
     }
 
-    const siteCount = await states.site.count({
-      $or: [{ domain: domainAlias }, { domainAliases: domainAlias }, { 'domainAliases.value': domainAlias }],
+    // check domain exists in site domain
+    const mainDomainSiteCount = await states.site.count({
+      domain: domainAlias,
     });
 
-    if (siteCount > 0) {
-      throw new Error(`domain alias ${domainAlias} already exists`);
+    if (mainDomainSiteCount > 0) {
+      if (!force) {
+        throw new Error(`${domainAlias} already exists`);
+      } else {
+        throw new Error(`${domainAlias} cannot be forced-added`);
+      }
+    }
+
+    // check domain exists in site alias domain
+    const aliasDomainSite = await states.site.findOne({
+      $or: [{ domainAliases: domainAlias }, { 'domainAliases.value': domainAlias }],
+    });
+
+    if (aliasDomainSite) {
+      if (!force) {
+        throw new Error(`${domainAlias} already exists`);
+      } else {
+        await this.deleteDomainAlias({ id: aliasDomainSite.id, domainAlias });
+      }
     }
 
     const updateResult = await states.site.update(
@@ -661,49 +681,51 @@ class RouterManager extends EventEmitter {
 
     // get child rules
     const blocklet = await states.blocklet.getBlocklet(rule.to.did);
-    for (const childMeta of blocklet.meta.children || []) {
-      for (const mountPoint of childMeta.mountPoints) {
-        const child = blocklet.children.find((b) => b.meta.name === childMeta.name);
-
-        if (!child) {
-          logger.error(`Child blocklet ${childMeta.name} does not exist`);
-          // eslint-disable-next-line no-continue
-          continue;
-        }
+    for (const child of blocklet.children || []) {
+      const { mountPoint } = child;
+      if (!mountPoint) {
+        logger.error(`mountPoint of child ${child.meta.name} does not exist`);
+        // eslint-disable-next-line no-continue
+        continue;
+      }
 
-        if (mountPoint.root.interfaceName === rule.to.interfaceName) {
-          const pathPrefix = path.join(rule.from.pathPrefix, mountPoint.root.prefix);
-          const isRootPath = pathPrefix === rule.from.pathPrefix;
-          if (isRootPath) {
-            occupied = true;
-          }
+      const childWebInterface = findWebInterface(child);
+      if (!childWebInterface) {
+        logger.error(`web interface of child ${child.meta.name} does not exist`);
+        // eslint-disable-next-line no-continue
+        continue;
+      }
 
-          // if is root path, child rule become root rule
-          const childRule = {
-            id: isRootPath ? rule.id : uuid.v4(),
-            groupId: rule.id,
-            from: {
-              pathPrefix: normalizePathPrefix(pathPrefix),
-              groupPathPrefix: rule.from.pathPrefix,
-            },
-            to: {
-              type: ROUTING_RULE_TYPES.BLOCKLET,
-              port: findInterfacePortByName(child, mountPoint.child.interfaceName),
-              did: rule.to.did, // root blocklet did
-              interfaceName: rule.to.interfaceName, // root blocklet interface
-              realDid: child.meta.did, // child blocklet did
-              realInterfaceName: mountPoint.child.interfaceName,
-            },
-            isProtected: isRootPath ? rule.isProtected : true,
-          };
-
-          rules.push(childRule);
-        }
+      const pathPrefix = path.join(rule.from.pathPrefix, mountPoint);
+      const isRootPath = pathPrefix === rule.from.pathPrefix;
+      if (isRootPath) {
+        occupied = true;
       }
+
+      // if is root path, child rule become root rule
+      const childRule = {
+        id: isRootPath ? rule.id : uuid.v4(),
+        groupId: rule.id,
+        from: {
+          pathPrefix: normalizePathPrefix(pathPrefix),
+          groupPathPrefix: rule.from.pathPrefix,
+        },
+        to: {
+          type: ROUTING_RULE_TYPES.BLOCKLET,
+          port: findInterfacePortByName(child, childWebInterface.name),
+          did: rule.to.did, // root blocklet did
+          interfaceName: rule.to.interfaceName, // root blocklet interface
+          realDid: child.meta.did, // child blocklet did
+          realInterfaceName: childWebInterface.name,
+        },
+        isProtected: isRootPath ? rule.isProtected : true,
+      };
+
+      rules.push(childRule);
     }
 
     // get root rule
-    if (!occupied) {
+    if (!occupied && blocklet.meta.group !== BlockletGroup.gateway) {
       rules.push(rule);
     }
 

package/lib/states/blocklet-extras.js

@@ -3,6 +3,7 @@
 /* eslint-disable consistent-return */
 const logger = require('@abtnode/logger')('state-blocklet-extras');
 const camelCase = require('lodash/camelCase');
+const get = require('lodash/get');
 
 const BaseState = require('./base');
 
@@ -36,16 +37,28 @@ class BlockletExtrasState extends BaseState {
         },
       },
     ];
+
+    this.childExtras = this.extras.filter((x) => ['configs'].includes(x.name));
+
     this.generateExtraFns();
   }
 
+  delete(did) {
+    return this.remove({ did });
+  }
+
   generateExtraFns() {
-    const methods = ['get', 'set', 'del'];
+    const methods = ['get', 'set', 'del', 'list'];
     methods.forEach((method) => {
       this.extras.forEach((extra) => {
         const fn = camelCase(`${method} ${extra.name}`); // getConfigs, getRules
         this[fn] = this.generateExtraFn(method, extra);
+      });
+    });
 
+    const childMethods = ['get', 'set', 'del'];
+    childMethods.forEach((method) => {
+      this.childExtras.forEach((extra) => {
         const childFn = camelCase(`${method} child ${extra.name}`); // getChildConfigs, getChildRules
         this[childFn] = this.generateExtraChildFn(method, extra);
       });
@@ -66,14 +79,22 @@ class BlockletExtrasState extends BaseState {
     if (method === 'del') {
       return this.generateDelFn(extra);
     }
+
+    if (method === 'list') {
+      return this.generateListFn(extra);
+    }
   }
 
   generateGetFn(extra) {
-    return async (did) => {
+    return async (did, path, defaultValue) => {
       const { dek } = this.options;
       const { name, afterGet = noop('data') } = extra;
       const item = await this.asyncDB.findOne({ did });
-      return afterGet({ data: item ? item[name] : item, did, dek });
+      const data = afterGet({ data: item ? item[name] : item, did, dek });
+      if (!path) {
+        return data;
+      }
+      return get(data, path, defaultValue);
     };
   }
 
@@ -118,6 +139,21 @@ class BlockletExtrasState extends BaseState {
     };
   }
 
+  generateListFn(extra) {
+    return async () => {
+      const { dek } = this.options;
+      const { name, afterGet = noop('data') } = extra;
+      const docs = await this.asyncDB.find({});
+      const list = docs
+        .filter((x) => x[name])
+        .map((x) => ({
+          did: x.did,
+          [name]: afterGet({ data: x[name], did: x.did, dek }),
+        }));
+      return list;
+    };
+  }
+
   // generate extra child functions
 
   generateExtraChildFn(method, extra) {

package/lib/states/blocklet.js

@@ -4,6 +4,7 @@
 /* eslint-disable no-underscore-dangle */
 const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
+const cloneDeep = require('lodash/cloneDeep');
 const detectPort = require('detect-port');
 const Lock = require('@abtnode/util/lib/lock');
 const security = require('@abtnode/util/lib/security');
@@ -119,7 +120,7 @@ class BlockletState extends BaseState {
             }
 
             this.emit('remove', doc);
-            return resolve(doc);
+            return resolve(formatBlocklet(doc, 'onRead', this.options.dek));
           });
         })
     );
@@ -130,9 +131,9 @@ class BlockletState extends BaseState {
     meta,
     source = BlockletSource.registry,
     status = BlockletStatus.added,
-    deployedFrom,
+    deployedFrom = '',
     mode = BLOCKLET_MODES.PRODUCTION,
-    childrenMeta = [],
+    children: rawChildren = [],
   } = {}) {
     return this.getBlocklet(did).then(
       (doc) =>
@@ -152,7 +153,7 @@ class BlockletState extends BaseState {
 
             const ports = await this.getBlockletPorts({ interfaces: sanitized.interfaces || [] });
 
-            const children = await this.fillChildrenPorts(this.getChildrenFromMetas(childrenMeta), {
+            const children = await this.fillChildrenPorts(rawChildren, {
               defaultPort: getMaxPort(ports),
             });
 
@@ -196,7 +197,7 @@ class BlockletState extends BaseState {
           }
 
           try {
-            const formatted = formatBlocklet(updates, 'onUpdate', this.options.dek);
+            const formatted = formatBlocklet(cloneDeep(updates), 'onUpdate', this.options.dek);
             const newDoc = await this.updateById(doc._id, { $set: formatted });
             resolve(newDoc);
           } catch (err) {
@@ -206,7 +207,7 @@ class BlockletState extends BaseState {
     );
   }
 
-  upgradeBlocklet({ meta, source, deployedFrom, children } = {}) {
+  upgradeBlocklet({ meta, source, deployedFrom = '', children } = {}) {
     return this.getBlocklet(meta.did).then(
       (doc) =>
         // eslint-disable-next-line no-async-promise-executor
@@ -247,8 +248,10 @@ class BlockletState extends BaseState {
               },
             });
             lock.release();
-            this.emit('upgrade', newDoc);
-            resolve(newDoc);
+
+            const formatted = formatBlocklet(newDoc, 'onRead', this.options.dek);
+            this.emit('upgrade', formatted);
+            resolve(formatted);
           } catch (err) {
             lock.release();
             reject(err);
@@ -392,11 +395,12 @@ class BlockletState extends BaseState {
     if (typeof status === 'undefined') {
       throw new Error('Unsupported blocklet status');
     }
-    const record = await this.getBlocklet(did);
-    // when status change update record
-    if (record.status === status) {
-      return record;
+
+    const doc = await this.getBlocklet(did);
+    if (doc.status === status) {
+      return formatBlocklet(doc, 'onRead', this.options.dek);
     }
+
     const updates = { status, startedAt: undefined, stoppedAt: undefined };
     if (status === BlockletStatus.running) {
       updates.startedAt = new Date();
@@ -408,14 +412,8 @@ class BlockletState extends BaseState {
       updates.stoppedAt = new Date();
     }
 
-    const res = await this.update(record._id, {
-      $set: updates,
-    });
-    return res;
-  }
-
-  getChildrenFromMetas(childrenMeta) {
-    return childrenMeta.map((x) => ({ meta: x }));
+    await this.update(doc._id, { $set: updates });
+    return formatBlocklet({ ...doc, ...updates }, 'onRead', this.options.dek);
   }
 
   async fillChildrenPorts(children, { defaultPort = 0, oldChildren } = {}) {

package/lib/states/node.js

@@ -49,7 +49,10 @@ class NodeState extends BaseState {
   }
 
   isInitialized(doc) {
-    return !!doc.nodeOwner;
+    const isOwnerConnected = !!doc.nodeOwner;
+    const isControlledBy3rdParty =
+      !doc.enablePassportIssuance && Array.isArray(doc.trustedPassports) && doc.trustedPassports.length > 0;
+    return isOwnerConnected || isControlledBy3rdParty;
   }
 
   /**
@@ -92,13 +95,15 @@ class NodeState extends BaseState {
           launcherInfo,
           didRegistry,
           didDomain,
+          enablePassportIssuance = true,
+          trustedPassports = [],
         } = this.options;
 
         if (nodeOwner && !validateOwner(nodeOwner)) {
           return reject(new Error('Node owner is invalid'));
         }
 
-        const initialized = this.isInitialized({ nodeOwner });
+        const initialized = this.isInitialized({ nodeOwner, enablePassportIssuance, trustedPassports });
 
         return getDefaultConfigs()
           .then((defaultConfigs) =>
@@ -126,6 +131,9 @@ class NodeState extends BaseState {
                 launcherInfo: launcherInfo || undefined,
                 didRegistry,
                 didDomain,
+                enablePassportIssuance,
+                trustedPassports,
+                customBlockletNumber: 0,
               },
               async (e, data) => {
                 if (e) {
@@ -255,12 +263,20 @@ class NodeState extends BaseState {
       ABT_NODE_PK: info.pk,
       ABT_NODE_PORT: info.port,
       ABT_NODE_SERVICE_PORT: process.env.ABT_NODE_SERVICE_PORT,
+      ABT_NODE_MODE: info.mode,
     }));
   }
 
   getBlockletRegistry() {
     return this.read().then((info) => info.blockletRegistryList.find((item) => item.selected).url);
   }
+
+  async increaseCustomBlockletNumber() {
+    const { _id, customBlockletNumber = 0 } = await this.read();
+    const num = customBlockletNumber + 1;
+    await this.update(_id, { $set: { customBlockletNumber: num } });
+    return num;
+  }
 }
 
 module.exports = NodeState;