@abtnode/core 1.7.18 → 1.7.21

package/lib/blocklet/migration.js

@@ -53,7 +53,7 @@ async function runScripts({
     const { script: scriptPath } = pendingScripts[i];
     try {
       printInfo(`Migration script started: ${scriptPath}`);
-      await runScript(`node ${path.join(scriptsDir, scriptPath)}`, [blocklet.env.appId, 'migration'].join(':'), {
+      await runScript(`node ${path.join(scriptsDir, scriptPath)}`, [blocklet.env.processId, 'migration'].join(':'), {
         cwd: appDir,
         env: getSafeEnv(env),
         silent: false,

package/lib/index.js

@@ -247,9 +247,10 @@ function ABTNode(options) {
     addBlockletStore: nodeAPI.addRegistry.bind(nodeAPI),
     deleteBlockletStore: nodeAPI.deleteRegistry.bind(nodeAPI),
     selectBlockletStore: nodeAPI.selectRegistry.bind(nodeAPI),
+    getDelegationState: nodeAPI.getDelegationState.bind(nodeAPI),
     cleanupDirtyUpgradeState: states.node.cleanupDirtyUpgradeState.bind(states.node),
-    addNodeOwner: states.node.addNodeOwner.bind(states.node),
     updateNodeOwner: states.node.updateNodeOwner.bind(states.node),
+    updateNftHolder: states.node.updateNftHolder.bind(states.node),
     updateNodeRouting,
     isInitialized,
     resetNode: (params, context) =>
@@ -261,7 +262,9 @@ function ABTNode(options) {
     // Team && Access control
 
     // Invitation
-    createInvitation: teamAPI.createInvitation.bind(teamAPI),
+    createMemberInvitation: teamAPI.createMemberInvitation.bind(teamAPI),
+    createTransferInvitation: teamAPI.createTransferInvitation.bind(teamAPI),
+    getInvitation: teamAPI.getInvitation.bind(teamAPI),
     getInvitations: teamAPI.getInvitations.bind(teamAPI),
     processInvitation: teamAPI.processInvitation.bind(teamAPI),
     deleteInvitation: teamAPI.deleteInvitation.bind(teamAPI),

package/lib/migrations/1.7.20-blocklet-component.js

@@ -0,0 +1,41 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-continue */
+
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to delete realDid, realInterface and add componentId in db...');
+
+  const sites = await states.site.find({});
+
+  for (const site of sites) {
+    let changed = false;
+    for (const rule of site.rules || []) {
+      if (!rule.to) {
+        continue;
+      }
+
+      if (rule.to.type !== 'blocklet') {
+        continue;
+      }
+
+      if (rule.to.componentId) {
+        continue;
+      }
+
+      if (!rule.to.realDid || rule.to.did === rule.to.realDid) {
+        rule.to.componentId = rule.to.did;
+      } else {
+        rule.to.componentId = `${rule.to.did}/${rule.to.realDid}`;
+      }
+
+      delete rule.to.realDid;
+      delete rule.to.realInterfaceName;
+
+      changed = true;
+    }
+
+    if (changed) {
+      await states.site.update({ _id: site._id }, site);
+      printInfo(`site ${site.domain} has been updated`);
+    }
+  }
+};

package/lib/router/helper.js

@@ -334,7 +334,7 @@ const ensureWellknownRule = async (sites) => {
         .sort((a, b) => (a.from.pathPrefix.length > b.from.pathPrefix.length ? 1 : -1));
       if (blockletRules.length) {
         // get pathPrefix for blocklet-service
-        const rootBlockletRule = blockletRules.find((x) => x.to.did === x.to.realDid);
+        const rootBlockletRule = blockletRules.find((x) => x.to.did === x.to.componentId);
         const pathPrefix = joinUrl(rootBlockletRule?.from?.pathPrefix || '/', WELLKNOWN_SERVICE_PATH_PREFIX);
 
         // requests for /.well-known/service will stay in blocklet-service and never proxy back to blocklet

package/lib/router/index.js

@@ -206,7 +206,7 @@ Router.formatSites = (sites = []) => {
               type: ROUTING_RULE_TYPES.DAEMON,
               port: daemonRule.to.port,
               did: rule.to.did,
-              realDid: rule.to.realDid,
+              componentId: rule.to.componentId,
             },
           });
 

package/lib/router/manager.js

@@ -29,6 +29,7 @@ const {
   BLOCKLET_INTERFACE_TYPE_WEB,
   BlockletGroup,
 } = require('@blocklet/meta/lib/constants');
+const { forEachChildSync } = require('@blocklet/meta/lib/util');
 
 const {
   validateAddSite,
@@ -112,7 +113,7 @@ class RouterManager extends EventEmitter {
       for (const rule of newSite.rules) {
         this.fixRootBlockletRule(rule);
         checkPathPrefixInBlackList(rule.from.pathPrefix, dynamicPathBlackList);
-        rules.push(...(await this.getRules(rule)));
+        rules.push(...(await this.getRulesForMutation(rule)));
       }
     }
     newSite.rules = rules;
@@ -281,7 +282,7 @@ class RouterManager extends EventEmitter {
     await this.validateRouterConfig('addRoutingRule', { id, rule });
 
     // add child blocklet rules
-    for (const x of await this.getRules(rule)) {
+    for (const x of await this.getRulesForMutation(rule)) {
       await states.site.addRuleToSite(id, x);
     }
 
@@ -323,7 +324,7 @@ class RouterManager extends EventEmitter {
     // update rules
     const newRules = [
       ...dbSite.rules.filter((x) => (x.groupId && x.groupId !== rule.id) || x.id !== rule.id), // 有些路由没有 rule.groupId
-      ...(await this.getRules(rule)),
+      ...(await this.getRulesForMutation(rule)),
     ];
 
     const updateResult = await states.site.update({ _id: id }, { $set: { rules: newRules } });
@@ -604,8 +605,7 @@ class RouterManager extends EventEmitter {
     rule.from.pathPrefix = normalizePathPrefix(rule.from.pathPrefix);
     if (rule.to.type === ROUTING_RULE_TYPES.BLOCKLET) {
       rule.from.groupPathPrefix = rule.from.pathPrefix;
-      rule.to.realDid = rule.to.did;
-      rule.to.realInterfaceName = rule.to.interfaceName;
+      rule.to.componentId = rule.to.did;
     }
     if (rule.to.url) {
       rule.to.url = normalizeRedirectUrl(rule.to.url);
@@ -616,7 +616,7 @@ class RouterManager extends EventEmitter {
    * get all rules to be add or update to site from root rule
    * @param {*} rule
    */
-  async getRules(rule) {
+  async getRulesForMutation(rule) {
     if (rule.to.type !== ROUTING_RULE_TYPES.BLOCKLET) {
       return [rule];
     }
@@ -626,23 +626,27 @@ class RouterManager extends EventEmitter {
 
     // get child rules
     const blocklet = await states.blocklet.getBlocklet(rule.to.did);
-    for (const child of blocklet.children || []) {
-      const { mountPoint } = child;
+    forEachChildSync(blocklet, (component, { id, ancestors }) => {
+      if (component.meta.group === BlockletGroup.gateway) {
+        return;
+      }
+
+      const { mountPoint } = component;
       if (!mountPoint) {
-        logger.error(`mountPoint of child ${child.meta.name} does not exist`);
+        logger.error(`mountPoint of child ${component.meta.name} does not exist`);
         // eslint-disable-next-line no-continue
-        continue;
+        return;
       }
 
-      const childWebInterface = findWebInterface(child);
+      const childWebInterface = findWebInterface(component);
       if (!childWebInterface) {
-        logger.error(`web interface of child ${child.meta.name} does not exist`);
+        logger.error(`web interface of child ${component.meta.name} does not exist`);
         // eslint-disable-next-line no-continue
-        continue;
+        return;
       }
 
-      const pathPrefix = path.join(rule.from.pathPrefix, mountPoint);
-      const isRootPath = pathPrefix === rule.from.pathPrefix;
+      const pathPrefix = path.join(rule.from.pathPrefix, ...ancestors.map((x) => x.mountPoint || ''), mountPoint);
+      const isRootPath = normalizePathPrefix(pathPrefix) === normalizePathPrefix(rule.from.pathPrefix);
       if (isRootPath) {
         occupied = true;
       }
@@ -657,17 +661,16 @@ class RouterManager extends EventEmitter {
         },
         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,
+          port: findInterfacePortByName(component, childWebInterface.name),
+          did: rule.to.did, // root component did
+          interfaceName: rule.to.interfaceName, // root component interface
+          componentId: id,
         },
         isProtected: isRootPath ? rule.isProtected : true,
       };
 
       rules.push(childRule);
-    }
+    });
 
     // get root rule
     if (!occupied && blocklet.meta.group !== BlockletGroup.gateway) {

package/lib/states/audit-log.js

@@ -110,7 +110,7 @@ const getLogContent = async (action, args, context, result, info, node) => {
     case 'deleteComponent':
       return `removed component ${args.did} from blocklet ${getBlockletInfo(result, info)}`;
     case 'configBlocklet':
-      return `updated following ${args.childDid ? `child ${args.childDid}` : ''} config for blocklet ${getBlockletInfo(result, info)}:\n${args.configs.map(x => `- ${x.key}: ${x.value}\n`)}`; // prettier-ignore
+      return `updated following config for blocklet ${getBlockletInfo(result, info)}:\n${args.configs.map(x => `- ${x.key}: ${x.value}\n`)}`; // prettier-ignore
     case 'upgradeBlocklet':
       return `upgraded blocklet ${getBlockletInfo(result, info)} to v${result.meta.version}`;
     case 'updateChildBlocklets':
@@ -154,7 +154,7 @@ const getLogContent = async (action, args, context, result, info, node) => {
       return `${args.user.approved ? 'enabled' : 'disabled'} user ${user} for ${team}`;
     case 'deletePassportIssuance':
       return `removed passport issuance ${args.sessionId} from ${team}`;
-    case 'createInvitation':
+    case 'createMemberInvitation':
       return `created member invitation(${result.inviteId}: ${args.remark}) with **${args.role}** passport for ${team}`; // prettier-ignore
     case 'deleteInvitation':
       return `removed unused member invitation(${args.inviteId}) from ${team}`;
@@ -169,6 +169,8 @@ const getLogContent = async (action, args, context, result, info, node) => {
         return `removed all trusted passport issuers for ${team}`;
       }
       return `updated trusted passport issuers to following for ${team}: \n${args.trustedPassports.map(x => `- ${x.remark}: ${x.issuerDid}`).join('\n')}`; // prettier-ignore
+    case 'delegateTransferNFT':
+      return `${args.owner} ${args.reason}`;
 
     // accessKeys
     case 'createAccessKey':
@@ -258,12 +260,13 @@ const getLogCategory = (action) => {
     case 'revokeUserPassport':
     case 'enableUserPassport':
     case 'updateUserApproval':
-    case 'createInvitation':
+    case 'createMemberInvitation':
     case 'deleteInvitation':
     case 'createRole':
     case 'updateRole':
     case 'updatePermissionsForRole':
     case 'configTrustedPassports':
+    case 'delegateTransferNFT':
       return 'team';
 
     // accessKeys
@@ -299,6 +302,25 @@ const getLogCategory = (action) => {
   }
 };
 
+const getScope = (args = {}) => {
+  // this param usually means mutating an application (server or blocklet)
+  if (args.teamDid) {
+    return args.teamDid;
+  }
+
+  // this param usually means mutating a child component
+  if (args.rootDid) {
+    return args.rootDid;
+  }
+
+  // this param usually means mutating a nested child component
+  if (Array.isArray(args.did)) {
+    return args.did[0];
+  }
+
+  return null;
+};
+
 class AuditLogState extends BaseState {
   constructor(baseDir, options = {}) {
     super(baseDir, { filename: 'audit-log.db', ...options });
@@ -355,7 +377,7 @@ class AuditLogState extends BaseState {
         const [info, geoInfo, uaInfo] = await Promise.all([node.states.node.read(), lookup(ip), parse(ua)]);
 
         const data = await this.asyncDB.insert({
-          scope: args.teamDid || info.did, // server or blocklet did
+          scope: getScope(args) || info.did, // server or blocklet did
           action,
           category: await getLogCategory(action, args, context, result, info, node),
           content: (await getLogContent(action, args, context, result, info, node)).trim(),

package/lib/states/blocklet-extras.js

@@ -52,22 +52,14 @@ class BlockletExtrasState extends BaseState {
     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);
+        this[fn] = this.generateFn(method, extra);
       });
     });
   }
 
-  // generate extra functions
+  // generate functions
 
-  generateExtraFn(method, extra) {
+  generateFn(method, extra) {
     if (method === 'get') {
       return this.generateGetFn(extra);
     }
@@ -86,11 +78,20 @@ class BlockletExtrasState extends BaseState {
   }
 
   generateGetFn(extra) {
-    return async (did, path, defaultValue) => {
+    return async (dids, path, defaultValue) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = [].concat(dids);
+      const [rootDid, ...childDids] = dids;
       const { dek } = this.options;
       const { name, afterGet = noop('data') } = extra;
-      const item = await this.asyncDB.findOne({ did });
-      const data = afterGet({ data: item ? item[name] : item, did, dek });
+
+      let item = await this.asyncDB.findOne({ did: rootDid });
+      while (item && childDids.length) {
+        const did = childDids.shift();
+        item = (item.children || []).find((x) => x.did === did);
+      }
+
+      const data = afterGet({ data: item ? item[name] : item, did: rootDid, dek });
       if (!path) {
         return data;
       }
@@ -99,43 +100,71 @@ class BlockletExtrasState extends BaseState {
   }
 
   generateSetFn(extra) {
-    return async (did, data) => {
+    return async (dids, data) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = [].concat(dids);
+      const [rootDid, ...childDids] = dids;
       const { dek } = this.options;
       const { name, beforeSet = noop('cur') } = extra;
-      const item = await this.asyncDB.findOne({ did });
+      const exist = await this.asyncDB.findOne({ did: rootDid });
+
+      const item = exist || { did: rootDid };
+      let component = item;
+      while (childDids.length) {
+        const did = childDids.shift();
+        component.children = component.children || [];
+        let child = component.children.find((x) => x.did === did);
+        if (!child) {
+          child = { did };
+          component.children.push(child);
+        }
+        component = child;
+      }
 
-      if (!item) {
-        const insertData = {
-          did,
-          [name]: beforeSet({ old: undefined, cur: data, did, dek }),
-        };
-
-        const info = await this.asyncDB.insert(insertData);
-        logger.info('create info success');
-        return info[name];
+      const old = component[name];
+      const newData = beforeSet({ old, cur: data, did: rootDid, dek });
+      component[name] = newData;
+
+      if (!exist) {
+        await this.asyncDB.insert(item);
+        logger.info('create extra success', { name, dids });
+      } else {
+        await this.update(item._id, item);
+        logger.info('update extra success', { name, dids });
       }
 
-      const itemNameValue = item[name];
-      const updated = await this.update(item._id, {
-        $set: {
-          [name]: beforeSet({ old: itemNameValue, cur: data, did, dek }),
-        },
-      });
-      return updated[name];
+      return newData;
     };
   }
 
   generateDelFn(extra) {
-    return async (did) => {
+    return async (dids) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = [].concat(dids);
+      const [rootDid, ...childDids] = dids;
       const { name } = extra;
-      const item = await this.asyncDB.findOne({ did });
+      const item = await this.asyncDB.findOne({ did: rootDid });
 
       if (!item) {
-        return item;
+        return null;
+      }
+
+      let component = item;
+      while (component && childDids.length) {
+        const did = childDids.shift();
+        component = (component.children || []).find((x) => x.did === did);
       }
 
-      await this.update(item._id, { $set: { [name]: null } });
-      return item[name];
+      if (!component) {
+        return null;
+      }
+
+      const updated = component[name];
+      component[name] = null;
+
+      await this.update(item._id, item);
+
+      return updated;
     };
   }
 
@@ -153,128 +182,6 @@ class BlockletExtrasState extends BaseState {
       return list;
     };
   }
-
-  // generate extra child functions
-
-  generateExtraChildFn(method, extra) {
-    if (method === 'get') {
-      return this.generateGetChildFn(extra);
-    }
-
-    if (method === 'set') {
-      return this.generateSetChildFn(extra);
-    }
-
-    if (method === 'del') {
-      return this.generateDelChildFn(extra);
-    }
-  }
-
-  generateGetChildFn(extra) {
-    return async (did, childDid) => {
-      const { dek } = this.options;
-      const { name, afterGet = noop('data') } = extra;
-      const item = await this.asyncDB.findOne({ did });
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
-      return afterGet({ data: subItem ? subItem[name] : null, did, dek });
-    };
-  }
-
-  generateSetChildFn(extra) {
-    return async (did, childDid, data) => {
-      const { dek } = this.options;
-      const { name, beforeSet = noop('cur') } = extra;
-      const item = await this.asyncDB.findOne({ did });
-
-      if (!item) {
-        const newData = beforeSet({ old: undefined, cur: data, did, dek });
-        const insertData = {
-          did,
-          children: [
-            {
-              did: childDid,
-              [name]: newData,
-            },
-          ],
-        };
-        await this.asyncDB.insert(insertData);
-
-        logger.info('create info success; insert child info success');
-
-        return newData;
-      }
-
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
-
-      if (!subItem) {
-        const newData = beforeSet({ old: undefined, cur: data, did, dek });
-        await this.update(item._id, {
-          $addToSet: {
-            children: {
-              did: childDid,
-              [name]: newData,
-            },
-          },
-        });
-
-        logger.info('insert child info success');
-        return newData;
-      }
-
-      const newData = beforeSet({ old: subItem[name], cur: data, did, dek });
-
-      children.forEach((x) => {
-        if (x.did === childDid) {
-          x[name] = newData;
-        }
-      });
-
-      await this.update(item._id, {
-        $set: {
-          children,
-        },
-      });
-
-      return newData;
-    };
-  }
-
-  generateDelChildFn(extra) {
-    return async (did, childDid) => {
-      const { name } = extra;
-      const item = await this.asyncDB.findOne({ did });
-
-      if (!item) {
-        return null;
-      }
-
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
-
-      if (!subItem) {
-        return null;
-      }
-
-      let updated = null;
-
-      children.forEach((x) => {
-        if (x.did === childDid) {
-          updated = x[name];
-          x[name] = null;
-        }
-      });
-
-      await this.update(item._id, {
-        $set: {
-          children,
-        },
-      });
-
-      return updated;
-    };
-  }
 }
 
 module.exports = BlockletExtrasState;