@abtnode/core 1.7.18 → 1.7.21

package/lib/util/blocklet.js

@@ -5,7 +5,6 @@ const path = require('path');
 const os = require('os');
 const tar = require('tar');
 const get = require('lodash/get');
-const intersection = require('lodash/intersection');
 const streamToPromise = require('stream-to-promise');
 const { Throttle } = require('stream-throttle');
 const ssri = require('ssri');
@@ -43,8 +42,19 @@ const validateBlockletEntry = require('@blocklet/meta/lib/entry');
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
 const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/validate');
-const { forEachBlocklet, isFreeBlocklet, getDisplayName, findWebInterface } = require('@blocklet/meta/lib/util');
+const {
+  forEachBlocklet,
+  isFreeBlocklet,
+  getDisplayName,
+  findWebInterface,
+  forEachBlockletSync,
+  forEachChildSync,
+  isComponentBlocklet,
+  getSharedConfigObj,
+  getComponentName,
+} = require('@blocklet/meta/lib/util');
 const toBlockletDid = require('@blocklet/meta/lib/did');
+const { titleSchema, descriptionSchema } = require('@blocklet/meta/lib/schema');
 
 const { validate: validateEngine, get: getEngine } = require('../blocklet/manager/engine');
 
@@ -97,44 +107,36 @@ const PRIVATE_NODE_ENVS = [
 
 /**
  * @returns { dataDir, logsDir, cacheDir, appMain, appDir, mainDir, appCwd }
- * dataDir: dataDirs.data/name (root blocklet) or dataDirs.data/name/childName (child blocklet)
+ * dataDir: dataDirs.data/name (root component) or dataDirs.data/name/childName (child component)
  * logsDir: dataDirs.log/name
- * cacheDir: dataDirs.cache/name (root blocklet) or dataDirs.cache/name/childName (child blocklet)
- * appDir: blocklet bundle dir
- * mainDir: appDir (dapp) or appDir/main (static). Used for for static blocklet
- * appMain: app entry file or script (run appMain to start blocklet process)
+ * cacheDir: dataDirs.cache/name (root component) or dataDirs.cache/name/childName (child component)
+ * appDir: component bundle dir
+ * mainDir: appDir (dapp) or appDir/main (static). Used for for static component
+ * appMain: app entry file or script (run appMain to start component process)
  * appCwd: cwd of appMain
  */
-const getBlockletDirs = (
-  blocklet,
-  { rootBlocklet, dataDirs, ensure = false, e2eMode = false, validate = true } = {}
+const getComponentDirs = (
+  component,
+  { dataDirs, ensure = false, e2eMode = false, validate = true, ancestors = [] } = {}
 ) => {
-  if (!rootBlocklet) {
-    // eslint-disable-next-line no-param-reassign
-    rootBlocklet = blocklet;
-  }
   // get data dirs
 
-  const { name } = blocklet.meta;
+  const { name: appName } = ancestors.concat(component)[0].meta;
+  const componentName = getComponentName(component, ancestors);
 
-  let logsDir = path.join(dataDirs.logs, name);
-  let dataDir = path.join(dataDirs.data, name);
-  let cacheDir = path.join(dataDirs.cache, name);
-  if (rootBlocklet !== blocklet) {
-    dataDir = path.join(dataDirs.data, rootBlocklet.meta.name, name);
-    cacheDir = path.join(dataDirs.cache, rootBlocklet.meta.name, name);
-    logsDir = path.join(dataDirs.logs, rootBlocklet.meta.name);
-  }
+  const logsDir = path.join(dataDirs.logs, appName);
+  const dataDir = path.join(dataDirs.data, componentName);
+  const cacheDir = path.join(dataDirs.cache, componentName);
 
   // get app dirs
 
-  const { main, group } = blocklet.meta;
+  const { main, group } = component.meta;
 
   let startFromDevEntry = '';
-  if (blocklet.mode === BLOCKLET_MODES.DEVELOPMENT && blocklet.meta.scripts) {
-    startFromDevEntry = blocklet.meta.scripts.dev;
-    if (e2eMode && blocklet.meta.scripts.e2eDev) {
-      startFromDevEntry = blocklet.meta.scripts.e2eDev;
+  if (component.mode === BLOCKLET_MODES.DEVELOPMENT && component.meta.scripts) {
+    startFromDevEntry = component.meta.scripts.dev;
+    if (e2eMode && component.meta.scripts.e2eDev) {
+      startFromDevEntry = component.meta.scripts.e2eDev;
     }
   }
 
@@ -145,10 +147,10 @@ const getBlockletDirs = (
   let appDir = null;
   let mainDir = null;
 
-  if (blocklet.source === BlockletSource.local) {
-    appDir = blocklet.deployedFrom;
+  if (component.source === BlockletSource.local) {
+    appDir = component.deployedFrom;
   } else {
-    appDir = getBundleDir(dataDirs.blocklets, blocklet.meta);
+    appDir = getBundleDir(dataDirs.blocklets, component.meta);
   }
 
   if (!appDir) {
@@ -168,9 +170,9 @@ const getBlockletDirs = (
 
   mainDir = appDir;
 
-  if (validate && !startFromDevEntry && !isBeforeInstalled(rootBlocklet.status)) {
+  if (validate && !startFromDevEntry && !isBeforeInstalled(component.status)) {
     try {
-      validateBlockletEntry(appDir, blocklet.meta);
+      validateBlockletEntry(appDir, component.meta);
     } catch (err) {
       throw new CustomError('BLOCKLET_CORRUPTED', err.message);
     }
@@ -186,7 +188,7 @@ const getBlockletDirs = (
     appMain = startFromDevEntry;
     appCwd = appDir;
   } else if (group === 'dapp') {
-    appMain = getBlockletEngine(blocklet.meta).script || BLOCKLET_ENTRY_FILE;
+    appMain = getBlockletEngine(component.meta).script || BLOCKLET_ENTRY_FILE;
     appCwd = appDir;
   } else if (group === 'static') {
     mainDir = path.join(appDir, main);
@@ -200,11 +202,11 @@ const getBlockletDirs = (
 };
 
 /**
- * set 'configs', configObj', 'environmentObj' to blocklet
+ * set 'configs', configObj', 'environmentObj' to blocklet TODO
  * @param {*} blocklet
  * @param {*} configs
  */
-const fillBlockletConfigs = (blocklet, configs, parent) => {
+const fillBlockletConfigs = (blocklet, configs) => {
   blocklet.configs = configs || [];
   blocklet.configObj = blocklet.configs.reduce((acc, x) => {
     acc[x.key] = x.value;
@@ -214,13 +216,6 @@ const fillBlockletConfigs = (blocklet, configs, parent) => {
     acc[x.key] = x.value;
     return acc;
   }, {});
-
-  const sharedConfigs = getSharedConfigs(blocklet, parent);
-  Object.keys(sharedConfigs).forEach((key) => {
-    blocklet.configObj[key] = sharedConfigs[key];
-    const item = blocklet.configs.find((x) => x.key === key);
-    item.value = sharedConfigs[key];
-  });
 };
 
 const ensureBlockletExpanded = async (meta, appDir) => {
@@ -243,7 +238,7 @@ const ensureBlockletExpanded = async (meta, appDir) => {
   }
 };
 
-const getRootSystemEnvironments = (blocklet, nodeInfo) => {
+const getAppSystemEnvironments = (blocklet, nodeInfo) => {
   const { did, name, title, description } = blocklet.meta;
   const keys = Object.keys(BLOCKLET_CONFIGURABLE_KEY);
   const result = getBlockletInfo(
@@ -273,7 +268,7 @@ const getRootSystemEnvironments = (blocklet, nodeInfo) => {
   };
 };
 
-const getOverwrittenEnvironments = (blocklet, nodeInfo) => {
+const getAppOverwrittenEnvironments = (blocklet, nodeInfo) => {
   const result = {};
   if (!blocklet || !blocklet.configObj) {
     return result;
@@ -306,7 +301,7 @@ const getOverwrittenEnvironments = (blocklet, nodeInfo) => {
   return result;
 };
 
-const getSystemEnvironments = (blocklet) => {
+const getComponentSystemEnvironments = (blocklet) => {
   const { port, ports } = blocklet;
   const portEnvironments = {};
   if (port) {
@@ -316,17 +311,17 @@ const getSystemEnvironments = (blocklet) => {
     Object.assign(portEnvironments, ports);
   }
   return {
+    BLOCKLET_REAL_DID: blocklet.env.id,
     BLOCKLET_DATA_DIR: blocklet.env.dataDir,
     BLOCKLET_LOG_DIR: blocklet.env.logsDir,
     BLOCKLET_CACHE_DIR: blocklet.env.cacheDir,
-    BLOCKLET_REAL_DID: blocklet.meta.did,
     BLOCKLET_APP_DIR: blocklet.env.appDir,
     BLOCKLET_MAIN_DIR: blocklet.env.mainDir,
     ...portEnvironments,
   };
 };
 
-const getRuntimeEnvironments = (blocklet, nodeEnvironments, parent) => {
+const getRuntimeEnvironments = (blocklet, nodeEnvironments, ancestors) => {
   // pm2 will force inject env variables of daemon process to blocklet process
   // we can only rewrite these private env variables to empty
   const safeNodeEnvironments = PRIVATE_NODE_ENVS.reduce((o, x) => {
@@ -335,30 +330,14 @@ const getRuntimeEnvironments = (blocklet, nodeEnvironments, parent) => {
   }, {});
 
   return {
-    ...blocklet.environmentObj,
     ...blocklet.configObj,
-    ...getSharedConfigs(blocklet, parent),
+    ...getSharedConfigObj(blocklet, ancestors),
+    ...blocklet.environmentObj,
     ...nodeEnvironments,
     ...safeNodeEnvironments,
   };
 };
 
-// we support share insecure same configs between parent and child blocklets
-const getSharedConfigs = (child, parent) => {
-  const sharedConfigs = {};
-  if (parent && Array.isArray(parent.configs) && child.meta.did !== parent.meta.did) {
-    const parentKeys = parent.configs.filter((x) => x.secure === false && x.shared !== false).map((x) => x.key);
-    const childKeys = child.configs.map((x) => x.key);
-    const sharedKeys = intersection(parentKeys, childKeys);
-    sharedKeys.forEach((key) => {
-      if (!child.configObj[key]) {
-        sharedConfigs[key] = parent.configObj[key];
-      }
-    });
-  }
-  return sharedConfigs;
-};
-
 const isUsefulError = (err) => err && err.message !== 'process or namespace not found';
 
 const getHealthyCheckTimeout = (blocklet, { checkHealthImmediately } = {}) => {
@@ -435,32 +414,40 @@ const getBlockletMetaFromUrls = async (urls) => {
  * Start all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const startBlockletProcess = async (blocklet, { preStart = noop, nodeEnvironments, nodeInfo, e2eMode } = {}) => {
+const startBlockletProcess = async (
+  blocklet,
+  { preStart = noop, nodeEnvironments, nodeInfo, e2eMode, skippedProcessIds = [] } = {}
+) => {
   if (!blocklet) {
     throw new Error('blocklet should not be empty');
   }
 
   await forEachBlocklet(
     blocklet,
-    async (b) => {
+    async (b, { ancestors }) => {
       if (b.meta.group === BlockletGroup.gateway) {
         return;
       }
 
-      const { appMain, appId, appCwd, logsDir } = b.env;
+      const { appMain, processId, appCwd, logsDir } = b.env;
+
+      if (skippedProcessIds.includes(processId)) {
+        logger.info(`skip start process ${processId}`);
+        return;
+      }
 
       // get env
-      const env = getRuntimeEnvironments(b, nodeEnvironments);
+      const env = getRuntimeEnvironments(b, nodeEnvironments, ancestors);
 
       // run hook
-      await preStart(b);
+      await preStart(b, { env });
 
       // start process
       const maxMemoryRestart = get(nodeInfo, 'runtimeConfig.blockletMaxMemoryLimit', BLOCKLET_MAX_MEM_LIMIT_IN_MB);
 
       const options = {
         namespace: 'blocklets',
-        name: appId,
+        name: processId,
         cwd: appCwd,
         time: true,
         output: path.join(logsDir, 'output.log'),
@@ -500,12 +487,12 @@ const startBlockletProcess = async (blocklet, { preStart = noop, nodeEnvironment
 
       await pm2.startAsync(options);
 
-      const status = await getProcessState(appId);
+      const status = await getProcessState(processId);
       if (status === BlockletStatus.error) {
-        throw new Error(`${appId} is not running within 5 seconds`);
+        throw new Error(`${processId} is not running within 5 seconds`);
       }
 
-      logger.info('blocklet started', { appId, status });
+      logger.info('blocklet started', { processId, status });
     },
     { parallel: true }
   );
@@ -515,12 +502,17 @@ const startBlockletProcess = async (blocklet, { preStart = noop, nodeEnvironment
  * Stop all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const stopBlockletProcess = async (blocklet, { preStop = noop } = {}) => {
+const stopBlockletProcess = async (blocklet, { preStop = noop, skippedProcessIds = [] } = {}) => {
   await forEachBlocklet(
     blocklet,
-    async (b) => {
-      await preStop(b);
-      await deleteProcess(b.env.appId);
+    async (b, { ancestors }) => {
+      if (skippedProcessIds.includes(b.env.processId)) {
+        logger.info(`skip stop process ${b.env.processId}`);
+        return;
+      }
+
+      await preStop(b, { ancestors });
+      await deleteProcess(b.env.processId);
     },
     { parallel: true }
   );
@@ -530,12 +522,17 @@ const stopBlockletProcess = async (blocklet, { preStop = noop } = {}) => {
  * Delete all precesses of a blocklet
  * @param {*} blocklet should contain env props
  */
-const deleteBlockletProcess = async (blocklet, { preDelete = noop } = {}) => {
+const deleteBlockletProcess = async (blocklet, { preDelete = noop, skippedProcessIds = [] } = {}) => {
   await forEachBlocklet(
     blocklet,
-    async (b) => {
-      await preDelete(b);
-      await deleteProcess(b.env.appId);
+    async (b, { ancestors }) => {
+      if (skippedProcessIds.includes(b.env.processId)) {
+        logger.info(`skip delete process ${b.env.processId}`);
+        return;
+      }
+
+      await preDelete(b, { ancestors });
+      await deleteProcess(b.env.processId);
     },
     { parallel: true }
   );
@@ -552,8 +549,8 @@ const reloadBlockletProcess = async (blocklet) =>
       if (b.meta.group === BlockletGroup.gateway) {
         return;
       }
-      logger.info('reload process', { appId: b.env.appId });
-      await reloadProcess(b.env.appId);
+      logger.info('reload process', { processId: b.env.processId });
+      await reloadProcess(b.env.processId);
     },
     { parallel: false }
   );
@@ -562,7 +559,7 @@ const getBlockletStatusFromProcess = async (blocklet) => {
   const tasks = [];
   await forEachBlocklet(blocklet, (b) => {
     if (b.meta.group !== BlockletGroup.gateway) {
-      tasks.push(getProcessState(b.env.appId));
+      tasks.push(getProcessState(b.env.processId));
     }
   });
 
@@ -592,11 +589,11 @@ const getRootBlockletStatus = (statusList = []) => {
 };
 
 /**
- * @param {*} appId
+ * @param {*} processId
  * @returns {BlockletStatus}
  */
-const getProcessState = async (appId) => {
-  const info = await getProcessInfo(appId);
+const getProcessState = async (processId) => {
+  const info = await getProcessInfo(processId);
   if (!statusMap[info.pm2_env.status]) {
     logger.error('Cannot find the blocklet status for pm2 status mapping', {
       pm2Status: info.pm2_env.status,
@@ -608,9 +605,9 @@ const getProcessState = async (appId) => {
   return statusMap[info.pm2_env.status];
 };
 
-const getProcessInfo = (appId) =>
+const getProcessInfo = (processId) =>
   new Promise((resolve, reject) => {
-    pm2.describe(appId, async (err, [info]) => {
+    pm2.describe(processId, async (err, [info]) => {
       if (err) {
         logger.error('Failed to get blocklet status from pm2', { error: err });
         return reject(err);
@@ -624,10 +621,10 @@ const getProcessInfo = (appId) =>
     });
   });
 
-const deleteProcess = (appId) =>
+const deleteProcess = (processId) =>
   new Promise((resolve, reject) => {
     pm2.connect(() => {
-      pm2.delete(appId, async (err) => {
+      pm2.delete(processId, async (err) => {
         if (isUsefulError(err)) {
           logger.error('blocklet process delete failed', { error: err });
           return reject(err);
@@ -637,9 +634,9 @@ const deleteProcess = (appId) =>
     });
   });
 
-const reloadProcess = (appId) =>
+const reloadProcess = (processId) =>
   new Promise((resolve, reject) => {
-    pm2.reload(appId, async (err) => {
+    pm2.reload(processId, async (err) => {
       if (err) {
         if (isUsefulError(err)) {
           logger.error('blocklet reload failed', { error: err });
@@ -696,7 +693,12 @@ const getSourceUrlsFromConfig = (config) => {
 /**
  * this function has side effect on children
  */
-const parseChildrenFromMeta = async (src, { dynamic } = {}) => {
+const parseChildrenFromMeta = async (src, context = {}) => {
+  const { dynamic, ancestors = [] } = context;
+  if (ancestors.length > 40) {
+    throw new Error('The depth of component should not exceed 40');
+  }
+
   const configs = Array.isArray(src) ? src : src.children || [];
 
   if (!configs || !configs.length) {
@@ -722,22 +724,42 @@ const parseChildrenFromMeta = async (src, { dynamic } = {}) => {
 
     validateBlockletMeta(m, { ensureDist: true });
 
+    verifyPurchase(m, context);
+
+    if (!isComponentBlocklet(m)) {
+      throw new Error(`The blocklet cannot be a component: ${m.title}`);
+    }
+
     const webInterface = findWebInterface(m);
     if (!webInterface) {
       throw new Error(`Web interface does not found in child ${config.name}`);
     }
 
+    // validate mountPoint
     const rule = webInterface.prefix;
-    if (rule !== BLOCKLET_DYNAMIC_PATH_PREFIX && normalizePathPrefix(rule) !== normalizePathPrefix(mountPoint)) {
-      throw new Error(`Prefix does not match in child ${config.name}. expected: ${rule}, resolved: ${mountPoint}`);
+    if (rule !== BLOCKLET_DYNAMIC_PATH_PREFIX) {
+      const fullMountPoint = path.join(
+        ancestors.map((x) => x.mountPoint || ''),
+        mountPoint
+      );
+      if (normalizePathPrefix(rule) !== normalizePathPrefix(fullMountPoint)) {
+        throw new Error(`Prefix does not match in child ${config.name}. expected: ${rule}, resolved: ${mountPoint}`);
+      }
     }
 
     const meta = ensureMeta(m, { name: config.name });
+
+    // check circular dependencies
+    if (ancestors.map((x) => x.meta?.bundleDid).indexOf(meta.bundleDid) > -1) {
+      throw new Error('Blocklet components have circular dependencies');
+    }
+
     if (config.title) {
       meta.title = config.title;
+      meta.title = await titleSchema.validateAsync(config.title);
     }
     if (config.description) {
-      meta.description = config.description;
+      meta.description = await descriptionSchema.validateAsync(config.description);
     }
 
     const child = {
@@ -746,6 +768,12 @@ const parseChildrenFromMeta = async (src, { dynamic } = {}) => {
       bundleSource: config.source || { url: config.resolved },
     };
 
+    child.children = await parseChildrenFromMeta(meta, {
+      ...context,
+      ancestors: [...ancestors, { meta, mountPoint }],
+      dynamic: false,
+    });
+
     children.push(child);
   }
 
@@ -775,7 +803,7 @@ const checkBlockletProcessHealthy = async (blocklet, { minConsecutiveTime, timeo
 const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout }) => {
   const { meta, ports, env } = blocklet;
   const { name } = meta;
-  const { appId } = env;
+  const { processId } = env;
 
   const webInterface = (meta.interfaces || []).find((x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB);
   if (!webInterface) {
@@ -787,10 +815,10 @@ const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout }) =
     // ensure pm2 status is 'online'
     const getStatus = async () => {
       try {
-        const info = await getProcessInfo(appId);
+        const info = await getProcessInfo(processId);
         return info.pm2_env.status;
       } catch (err) {
-        logger.error('blocklet checkStart error', { error: err, appId, name });
+        logger.error('blocklet checkStart error', { error: err, processId, name });
         return '';
       }
     };
@@ -819,7 +847,7 @@ const _checkProcessHealthy = async (blocklet, { minConsecutiveTime, timeout }) =
       throw error;
     }
   } catch (error) {
-    logger.error('start blocklet failed', { appId, name });
+    logger.error('start blocklet failed', { processId, name });
     throw error;
   }
 };
@@ -870,15 +898,16 @@ const pruneBlockletBundle = async ({ blocklets, installDir, blockletSettings })
   // blockletMap: { <[scope/]name/version>: true }
   const blockletMap = {};
   for (const blocklet of blocklets) {
-    blockletMap[`${blocklet.meta.bundleName}/${blocklet.meta.version}`] = true;
-    for (const child of blocklet.children || []) {
-      blockletMap[`${child.meta.bundleName}/${child.meta.version}`] = true;
-    }
+    forEachBlockletSync(blocklet, (component) => {
+      blockletMap[`${component.meta.bundleName}/${component.meta.version}`] = true;
+    });
   }
   for (const setting of blockletSettings) {
     for (const child of setting.children || []) {
       if (child.status !== BlockletStatus.deleted) {
-        blockletMap[`${child.meta.bundleName}/${child.meta.version}`] = true;
+        forEachBlockletSync(child, (component) => {
+          blockletMap[`${component.meta.bundleName}/${component.meta.version}`] = true;
+        });
       }
     }
   }
@@ -993,8 +1022,8 @@ const getDiskInfo = async (blocklet, { useFakeDiskInfo } = {}) => {
   }
 };
 
-const getRuntimeInfo = async (appId) => {
-  const proc = await getProcessInfo(appId);
+const getRuntimeInfo = async (processId) => {
+  const proc = await getProcessInfo(processId);
   return {
     pid: proc.pid,
     uptime: proc.pm2_env ? +new Date() - Number(proc.pm2_env.pm_uptime) : 0,
@@ -1084,15 +1113,23 @@ const fixAndVerifyMetaFromStore = (meta) => {
   return fixAndValidateService(meta);
 };
 
-const getUpdateMetaList = (oldMetas = [], newMetas = []) => {
-  const oldMap = oldMetas.reduce((obj, x) => {
-    if (x.did) {
-      obj[x.did] = x.version;
+const getUpdateMetaList = (oldBlocklet = {}, newBlocklet = {}) => {
+  const oldMap = {};
+  forEachChildSync(oldBlocklet, (b, { id }) => {
+    if (b.bundleSource) {
+      oldMap[id] = b.meta.version;
     }
-    return obj;
-  }, {});
+  });
+
+  const res = [];
 
-  return newMetas.filter(({ version, did }) => did && version !== oldMap[did]);
+  forEachChildSync(newBlocklet, (b, { id }) => {
+    if (b.bundleSource && b.meta.version !== oldMap[id]) {
+      res.push({ id, meta: b.meta });
+    }
+  });
+
+  return res;
 };
 
 const getSourceFromInstallParams = (params) => {
@@ -1131,7 +1168,7 @@ const checkDuplicateComponents = (components = []) => {
     (item, index) => components.findIndex((x) => x.mountPoint === item.mountPoint) !== index
   );
   if (duplicateMountPoints.length) {
-    throw new Error(`mountpoint must be unique: ${duplicateMountPoints.map((x) => x.mountPoint).join(', ')}`);
+    throw new Error(`mount point must be unique: ${duplicateMountPoints.map((x) => x.mountPoint).join(', ')}`);
   }
 };
 
@@ -1187,11 +1224,7 @@ const needBlockletDownload = (blocklet, oldBlocklet) => {
     return true;
   }
 
-  if (get(oldBlocklet, 'meta.dist.integrity') === get(blocklet, 'meta.dist.integrity')) {
-    return false;
-  }
-
-  return true;
+  return !(get(oldBlocklet, 'meta.dist.integrity') === get(blocklet, 'meta.dist.integrity'));
 };
 
 const verifyPurchase = (meta, opts = {}) => {
@@ -1252,10 +1285,10 @@ module.exports = {
   getBlockletMetaFromUrl,
   parseChildrenFromMeta,
   parseChildren,
-  getBlockletDirs,
-  getRootSystemEnvironments,
-  getSystemEnvironments,
-  getOverwrittenEnvironments,
+  getComponentDirs,
+  getAppSystemEnvironments,
+  getAppOverwrittenEnvironments,
+  getComponentSystemEnvironments,
   getRuntimeEnvironments,
   validateBlocklet,
   fillBlockletConfigs,

package/lib/util/index.js

@@ -14,6 +14,7 @@ const { Certificate } = require('@fidm/x509');
 const getPortLib = require('get-port');
 const v8 = require('v8');
 const normalizePathPrefix = require('@abtnode/util/lib/normalize-path-prefix');
+const axios = require('@abtnode/util/lib/axios');
 const parseBlockletMeta = require('@blocklet/meta/lib/parse');
 const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/validate');
 const { BlockletStatus, BLOCKLET_INTERFACE_WELLKNOWN } = require('@blocklet/meta/lib/constants');
@@ -503,6 +504,33 @@ const getStateCrons = (states) => [
   },
 ];
 
+const getDelegateState = async (chainHost, address) => {
+  const result = await axios.post(
+    joinUrl(chainHost, '/gql/'),
+    JSON.stringify({
+      query: `{
+        getDelegateState(address: "${address}") {
+          state {
+            address
+            ops {
+              key
+            }
+          }
+        }
+      }`,
+    }),
+    {
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+      },
+      timeout: 60 * 1000,
+    }
+  );
+
+  return get(result.data, 'data.getDelegateState.state');
+};
+
 const lib = {
   validateOwner,
   getProviderFromNodeInfo,
@@ -541,6 +569,7 @@ const lib = {
   getSafeEnv,
   memoizeAsync,
   getStateCrons,
+  getDelegateState,
 };
 
 module.exports = lib;

package/lib/validators/router.js

@@ -44,7 +44,6 @@ const ruleSchema = {
       )
       .required(),
     did: Joi.string().label('did').when('type', { is: ROUTING_RULE_TYPES.BLOCKLET, then: Joi.required() }), // root blocklet did
-    realDid: Joi.string().label('real did'), // child blocklet did
     port: Joi.number().label('port').port().when('type', { is: ROUTING_RULE_TYPES.BLOCKLET, then: Joi.required() }),
     url: Joi.string().label('url').when('type', { is: ROUTING_RULE_TYPES.REDIRECT, then: Joi.required() }),
     redirectCode: Joi.alternatives()
@@ -54,13 +53,13 @@ const ruleSchema = {
     interfaceName: Joi.string() // root interface
       .label('interface name')
       .when('type', { is: ROUTING_RULE_TYPES.BLOCKLET, then: Joi.required() }),
-    realInterfaceName: Joi.string().label('real interface name'), // child blocklet interface
     response: Joi.object({ status: Joi.number().required(), contentType: Joi.string(), body: Joi.string().required() })
       .label('response')
       .when('type', {
         is: ROUTING_RULE_TYPES.DIRECT_RESPONSE,
         then: Joi.required(),
       }),
+    componentId: Joi.string().label('component id'), // component global id
   },
 
   // List of services that manipulate the request before the upstream blocklet