@abtnode/core 1.6.16 → 1.6.17

package/lib/index.js

@@ -197,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),

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

@@ -317,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;
         }

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');
@@ -679,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

@@ -131,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) =>
@@ -153,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),
             });
 
@@ -207,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
@@ -416,10 +416,6 @@ class BlockletState extends BaseState {
     return formatBlocklet({ ...doc, ...updates }, 'onRead', this.options.dek);
   }
 
-  getChildrenFromMetas(childrenMeta) {
-    return childrenMeta.map((x) => ({ meta: x }));
-  }
-
   async fillChildrenPorts(children, { defaultPort = 0, oldChildren } = {}) {
     let _maxPort = defaultPort;
     for (const child of children || []) {

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) {
@@ -262,6 +270,13 @@ class NodeState extends BaseState {
   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;