@abtnode/core 1.8.15 → 1.8.18

package/lib/states/cache.js

@@ -5,13 +5,15 @@ const BaseState = require('./base');
  * This db is used to save arbitrary cached data.
  */
 class CacheState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'cache.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'cache.db', ...config });
 
-    this.db.ensureIndex({ fieldName: 'key', unique: true }, (error) => {
-      if (error) {
-        logger.error('ensure index failed', { error });
-      }
+    this.onReady(() => {
+      this.ensureIndex({ fieldName: 'key', unique: true }, (error) => {
+        if (error) {
+          logger.error('ensure index failed', { error });
+        }
+      });
     });
   }
 

package/lib/states/challenge.js

@@ -9,17 +9,17 @@ class ChallengeState extends BaseState {
   /**
    * Creates an instance of ChallengeState
    * @param {string} baseDir
-   * @param {object} options
+   * @param {object} config
    * @memberof ChallengeState
    */
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'challenge.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'challenge.db', ...config });
   }
 
   generate() {
     return new Promise((resolve, reject) => {
       const challenge = stripHexPrefix(Mcrypto.getRandomBytes(16)).toUpperCase();
-      this.db.insert({ challenge }, (err, data) => {
+      this.insert({ challenge }, (err, data) => {
         if (err) {
           logger.error('generating error', { error: err });
           return reject(err);
@@ -38,7 +38,7 @@ class ChallengeState extends BaseState {
         return;
       }
 
-      this.db.findOne({ challenge }, (err, data) => {
+      this.findOne({ challenge }, (err, data) => {
         if (err) {
           logger.error('error find challenge', { error: err });
         }

package/lib/states/index.js

@@ -12,19 +12,19 @@ const ExtrasState = require('./blocklet-extras');
 const CacheState = require('./cache');
 const AuditLogState = require('./audit-log');
 
-const init = (dataDirs, options) => {
-  const notificationState = new NotificationState(dataDirs.core, options);
-  const nodeState = new NodeState(dataDirs.core, options, dataDirs, notificationState);
-  const blockletState = new BlockletState(dataDirs.core, options);
-  const challengeState = new ChallengeState(dataDirs.core, options);
-  const siteState = new SiteState(dataDirs.core, options);
-  const accessKeyState = new AccessKeyState(dataDirs.core, options);
-  const webhookState = new WebhookState(dataDirs.core, options);
-  const migrationState = new MigrationState(dataDirs.core, options);
-  const sessionState = new SessionState(dataDirs.core, options);
-  const extrasState = new ExtrasState(dataDirs.core, options);
-  const cacheState = new CacheState(dataDirs.core, options);
-  const auditLogState = new AuditLogState(dataDirs.core, options);
+const init = (dataDirs, config) => {
+  const notificationState = new NotificationState(dataDirs.core, config);
+  const nodeState = new NodeState(dataDirs.core, config, dataDirs, notificationState);
+  const blockletState = new BlockletState(dataDirs.core, config);
+  const challengeState = new ChallengeState(dataDirs.core, config);
+  const siteState = new SiteState(dataDirs.core, config);
+  const accessKeyState = new AccessKeyState(dataDirs.core, config);
+  const webhookState = new WebhookState(dataDirs.core, config);
+  const migrationState = new MigrationState(dataDirs.core, config);
+  const sessionState = new SessionState(dataDirs.core, config);
+  const extrasState = new ExtrasState(dataDirs.core, config);
+  const cacheState = new CacheState(dataDirs.core, config);
+  const auditLogState = new AuditLogState(dataDirs.core, config);
 
   return {
     node: nodeState,

package/lib/states/migration.js

@@ -4,14 +4,14 @@ const logger = require('@abtnode/logger')('@abtnode/core:states:migration');
 const BaseState = require('./base');
 
 class MigrationState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'migration.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'migration.db', ...config });
   }
 
   // eslint-disable-next-line no-unused-vars
   async isExecuted({ script, version }, context) {
     try {
-      const item = await this.asyncDB.findOne({ script, version });
+      const item = await this.findOne({ script, version });
       return !!item;
     } catch (err) {
       logger.error('failed to find migration', { script, version });
@@ -22,7 +22,7 @@ class MigrationState extends BaseState {
   // eslint-disable-next-line no-unused-vars
   async markExecuted({ script, version }, context) {
     try {
-      const result = await this.asyncDB.insert({ script, version, executedAt: new Date() });
+      const result = await this.insert({ script, version, executedAt: new Date() });
       logger.info('mark executed', result);
       return result;
     } catch (error) {

package/lib/states/node.js

@@ -15,23 +15,23 @@ class NodeState extends BaseState {
   /**
    * Creates an instance of NodeState.
    * @param {string} baseDir
-   * @param {object} options
+   * @param {object} config
    * @memberof NodeState
    */
-  constructor(baseDir, options = {}, dataDirs = {}, notification) {
-    super(baseDir, { filename: 'node.db', ...options });
+  constructor(baseDir, config = {}, dataDirs = {}, notification) {
+    super(baseDir, { filename: 'node.db', ...config });
 
     // Initialize the store
-    if (!options.nodeSk) {
+    if (!config.nodeSk) {
       throw new Error('Can not initialize node store without valid nodeSk');
     }
-    if (!options.nodePk) {
+    if (!config.nodePk) {
       throw new Error('Can not initialize node store without valid nodePk');
     }
-    if (!options.nodeDid) {
+    if (!config.nodeDid) {
       throw new Error('Can not initialize node store without valid nodeDid');
     }
-    if (!isFromPublicKey(options.nodeDid, options.nodePk)) {
+    if (!isFromPublicKey(config.nodeDid, config.nodePk)) {
       throw new Error('Node pk and did does not match');
     }
 
@@ -39,7 +39,7 @@ class NodeState extends BaseState {
     this.notification = notification;
 
     this.onReady(() => {
-      this.db.ensureIndex({ fieldName: 'did', unique: true }, (err) => {
+      this.ensureIndex({ fieldName: 'did', unique: true }, (err) => {
         if (err) {
           console.error('Failed to ensure unique index', err);
         }
@@ -62,8 +62,8 @@ class NodeState extends BaseState {
    */
   read() {
     return new Promise((resolve, reject) => {
-      const { nodeDid, dek } = this.options;
-      this.db.findOne({ did: this.options.nodeDid }, (err, record) => {
+      const { nodeDid, dek } = this.config;
+      this.findOne({ did: nodeDid }, (err, record) => {
         if (err) {
           // eslint-disable-next-line no-console
           console.error(err);
@@ -97,7 +97,7 @@ class NodeState extends BaseState {
           enablePassportIssuance = true,
           trustedPassports = [],
           webWalletUrl,
-        } = this.options;
+        } = this.config;
 
         if (nodeOwner && !validateOwner(nodeOwner)) {
           return reject(new Error('Node owner is invalid'));
@@ -107,7 +107,7 @@ class NodeState extends BaseState {
 
         return getDefaultConfigs()
           .then((defaultConfigs) =>
-            this.db.insert(
+            this.insert(
               {
                 ...(defaultConfigs || {}),
                 name,

package/lib/states/notification.js

@@ -5,11 +5,11 @@ const { EVENTS } = require('@abtnode/constant');
 const BaseState = require('./base');
 
 class NotificationState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'notification.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'notification.db', ...config });
 
-    this.defaultSender = options.defaultSender || '';
-    this.defaultReceiver = options.defaultReceiver || '';
+    this.defaultSender = config.defaultSender || '';
+    this.defaultReceiver = config.defaultReceiver || '';
   }
 
   setDefaultSender(sender) {
@@ -28,7 +28,7 @@ class NotificationState extends BaseState {
     });
 
     return new Promise((resolve, reject) => {
-      this.db.insert(
+      this.insert(
         {
           sender: payload.sender || this.defaultSender,
           receiver: payload.receiver || this.defaultReceiver,
@@ -54,7 +54,7 @@ class NotificationState extends BaseState {
     });
   }
 
-  async find({ receiver, sender, read, paging } = {}, context) {
+  async findPaginated({ receiver, sender, read, paging } = {}, context) {
     const conditions = {};
     // eslint-disable-next-line no-param-reassign
     receiver = receiver || get(context, 'user.did');
@@ -81,7 +81,7 @@ class NotificationState extends BaseState {
     logger.info('mark notification as read', { idList });
 
     return new Promise((resolve, reject) => {
-      this.db.update(
+      this.update(
         { _id: { $in: idList } },
         { $set: { read: true } },
         { multi: true, upsert: false, returnUpdatedDocs: false },
@@ -101,7 +101,7 @@ class NotificationState extends BaseState {
     const idList = Array.isArray(id) ? id : [id];
 
     return new Promise((resolve, reject) => {
-      this.db.update(
+      this.update(
         { _id: { $in: idList } },
         { $set: { read: false } },
         { multi: true, upsert: false, returnUpdatedDocs: false },

package/lib/states/session.js

@@ -5,24 +5,26 @@ const BaseState = require('./base');
  * This db is used to save session data generated in a http session. the session is NOT user auth session.
  */
 class SessionState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'session.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'session.db', ...config });
 
-    this.db.ensureIndex({ fieldName: 'createdAt' }, (error) => {
-      if (error) {
-        logger.error('ensure createdAt index failed', { error });
-      }
-    });
+    this.onReady(() => {
+      this.ensureIndex({ fieldName: 'createdAt' }, (error) => {
+        if (error) {
+          logger.error('ensure createdAt index failed', { error });
+        }
+      });
 
-    this.db.ensureIndex({ fieldName: 'expireDate', expireAfterSeconds: 0 }, (error) => {
-      if (error) {
-        logger.error('ensure expireDate index failed', { error });
-      }
+      this.ensureIndex({ fieldName: 'expireDate', expireAfterSeconds: 0 }, (error) => {
+        if (error) {
+          logger.error('ensure expireDate index failed', { error });
+        }
+      });
     });
   }
 
   async start(initialData) {
-    const { _id, ...data } = await this.asyncDB.insert(initialData);
+    const { _id, ...data } = await this.insert(initialData);
     return { id: _id, ...data };
   }
 
@@ -35,7 +37,7 @@ class SessionState extends BaseState {
 
     // eslint-disable-next-line no-underscore-dangle
     delete exist._id;
-    await this.asyncDB.update({ _id: id }, { $set: { ...exist, ...data } }, { multi: false, upsert: false });
+    await super.update({ _id: id }, { $set: { ...exist, ...data } }, { multi: false, upsert: false });
 
     return { id, ...exist, ...data };
   }
@@ -57,7 +59,7 @@ class SessionState extends BaseState {
       throw new Error(`Session does not exist: ${id}`);
     }
 
-    await this.asyncDB.remove({ _id: id });
+    await this.remove({ _id: id });
 
     data.id = id;
     return data;

package/lib/states/site.js

@@ -4,12 +4,12 @@ const { toSlotDomain } = require('@abtnode/router-provider/lib/util');
 const BaseState = require('./base');
 
 class SiteState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'routing_rule.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'routing_rule.db', ...config });
   }
 
   async add(rule) {
-    const result = await this.asyncDB.insert(rule);
+    const result = await this.insert(rule);
 
     const tmpRule = SiteState.renameIdFiledName(result);
     logger.info('rule created', { rule: tmpRule });
@@ -17,7 +17,7 @@ class SiteState extends BaseState {
   }
 
   async addRuleToSite(id, rule) {
-    const addedCount = await this.asyncDB.update({ _id: id }, { $addToSet: { rules: rule } });
+    const addedCount = await this.update({ _id: id }, { $addToSet: { rules: rule } });
 
     logger.info('added rule to site', { count: addedCount });
     return addedCount;
@@ -26,21 +26,21 @@ class SiteState extends BaseState {
   async getSites(...args) {
     let result = null;
     if (args.length === 0) {
-      result = await this.asyncDB.find({});
+      result = await this.find({});
     } else {
-      result = await this.asyncDB.find(...args);
+      result = await this.find(...args);
     }
 
     return SiteState.renameIdFiledName(result);
   }
 
   async getSitesByBlocklet(did) {
-    const rules = await this.asyncDB.find({ 'rules.to.did': did });
+    const rules = await this.find({ 'rules.to.did': did });
     return SiteState.renameIdFiledName(rules);
   }
 
   async getRuleById(id) {
-    const site = await this.asyncDB.findOne({ 'rules.id': id });
+    const site = await this.findOne({ 'rules.id': id });
     if (!site) {
       return null;
     }
@@ -48,20 +48,8 @@ class SiteState extends BaseState {
     return site.rules.find((x) => x.id === id);
   }
 
-  async update(...args) {
-    return this.asyncDB.update(...args);
-  }
-
-  async count(...args) {
-    return this.asyncDB.count(...args);
-  }
-
-  async remove(...args) {
-    return this.asyncDB.remove(...args);
-  }
-
   async findOne(...args) {
-    const site = await this.asyncDB.findOne(...args);
+    const site = await super.findOne(...args);
     if (!site) {
       return site;
     }
@@ -80,7 +68,7 @@ class SiteState extends BaseState {
   async findOneByDomain(domain) {
     // eslint-disable-next-line no-param-reassign
     domain = toSlotDomain(domain);
-    return this.asyncDB.findOne({
+    return this.findOne({
       $or: [{ domain }, { domainAliases: domain }, { 'domainAliases.value': domain }],
     });
   }

package/lib/states/user.js

@@ -5,20 +5,18 @@ const { PASSPORT_STATUS } = require('@abtnode/constant');
 const BaseState = require('./base');
 const { validateOwner } = require('../util');
 
-const fixPassports = (doc) => {
-  doc.passports = (doc.passports || []).filter((x) => x.id);
-};
-
 const isNullOrUndefined = (x) => x === undefined || x === null;
 
 class User extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'user.db', ...options });
-
-    this.db.ensureIndex({ fieldName: 'did', unique: true }, (error) => {
-      if (error) {
-        logger.error('ensure index failed', { error });
-      }
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'user.db', ...config });
+
+    this.onReady(() => {
+      this.ensureIndex({ fieldName: 'did', unique: true }, (error) => {
+        if (error) {
+          logger.error('ensure index failed', { error });
+        }
+      });
     });
   }
 
@@ -120,10 +118,6 @@ class User extends BaseState {
     // get data
     const { list, paging } = await this.paginate(queryParam, sortParam, inputPaging);
 
-    if (list) {
-      list.forEach(fixPassports); // backward compatible
-    }
-
     return {
       list,
       paging,
@@ -131,11 +125,7 @@ class User extends BaseState {
   }
 
   async getUser(did) {
-    const doc = await super.findOne({ did });
-    if (doc) {
-      fixPassports(doc); // backward compatible
-    }
-
+    const doc = await this.findOne({ did });
     return doc;
   }
 
@@ -145,7 +135,7 @@ class User extends BaseState {
    * @param {string} status passport status
    */
   async _setPassportStatusById({ did, id, status } = {}) {
-    const exist = await super.findOne({ did });
+    const exist = await this.findOne({ did });
 
     if (!exist) {
       throw new Error('did does not exist');

package/lib/states/webhook.js

@@ -4,8 +4,8 @@ const BaseState = require('./base');
 const { validateWebhook } = require('../validators/webhook');
 
 class WebhookState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'webhook.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'webhook.db', ...config });
   }
 
   async create(info, { mock } = {}) {
@@ -30,7 +30,7 @@ class WebhookState extends BaseState {
       return data;
     }
 
-    const webhook = await this.asyncDB.insert(data);
+    const webhook = await this.insert(data);
     return webhook;
   }
 
@@ -46,7 +46,7 @@ class WebhookState extends BaseState {
       throw new Error('webhookId should not be empty');
     }
     const webhook = await this.findOne(id);
-    const num = await this.asyncDB.remove({ _id: id });
+    const num = await this.remove({ _id: id });
     if (num <= 0) {
       throw new Error(`${id} does not exist`);
     }
@@ -56,7 +56,7 @@ class WebhookState extends BaseState {
 
   async findOne(id) {
     try {
-      const webhook = await this.asyncDB.findOne({ _id: id });
+      const webhook = await super.findOne({ _id: id });
 
       return webhook;
     } catch (error) {

package/lib/util/blocklet.js

@@ -11,6 +11,7 @@ const ssri = require('ssri');
 const diff = require('deep-diff');
 
 const { toHex } = require('@ocap/util');
+const { isValid: isValidDid } = require('@arcblock/did');
 const logger = require('@abtnode/logger')('@abtnode/core:util:blocklet');
 const pm2 = require('@abtnode/util/lib/async-pm2');
 const sleep = require('@abtnode/util/lib/sleep');
@@ -58,11 +59,13 @@ const {
   getBlockletMetaFromUrls,
   getBlockletMetaFromUrl,
 } = require('@blocklet/meta/lib/util-meta');
+const getComponentProcessId = require('@blocklet/meta/lib/get-component-process-id');
 
 const { validate: validateEngine, get: getEngine } = require('../blocklet/manager/engine');
 
 const isRequirementsSatisfied = require('./requirement');
 const { getDidDomainForBlocklet } = require('./get-domain-for-blocklet');
+const { getBlockletDomainGroupName } = require('./router');
 const { isBeforeInstalled, expandBundle, findInterfacePortByName, validateBlockletMeta } = require('./index');
 
 /**
@@ -73,6 +76,7 @@ const { isBeforeInstalled, expandBundle, findInterfacePortByName, validateBlockl
 const getBlockletEngineNameByPlatform = (blockletMeta) => getBlockletEngine(blockletMeta).interpreter;
 
 const noop = () => {};
+const noopAsync = async () => {};
 
 const statusMap = {
   online: BlockletStatus.running,
@@ -83,7 +87,7 @@ const statusMap = {
 };
 
 const PRIVATE_NODE_ENVS = [
-  // 'NEDB_MULTI_PORT', // FIXME: 排查 abtnode 对外提供的 SDK(比如 @abtnode/queue), SDK 中不要自动使用 NEDB_MULTI_PORT 环境变量
+  'NEDB_MULTI_PORT',
   'ABT_NODE_UPDATER_PORT',
   'ABT_NODE_SESSION_TTL',
   'ABT_NODE_ROUTER_PROVIDER',
@@ -208,7 +212,8 @@ const fillBlockletConfigs = (blocklet, configs) => {
     acc[x.key] = x.value;
     return acc;
   }, {});
-  blocklet.environmentObj = (blocklet.environments || []).reduce((acc, x) => {
+  blocklet.environments = blocklet.environments || [];
+  blocklet.environmentObj = blocklet.environments.reduce((acc, x) => {
     acc[x.key] = x.value;
     return acc;
   }, {});
@@ -408,7 +413,7 @@ const getHealthyCheckTimeout = (blocklet, { checkHealthImmediately } = {}) => {
  */
 const startBlockletProcess = async (
   blocklet,
-  { preStart = noop, nodeEnvironments, nodeInfo, e2eMode, skippedProcessIds = [] } = {}
+  { preStart = noop, postStart = noopAsync, nodeEnvironments, nodeInfo, e2eMode, skippedProcessIds = [] } = {}
 ) => {
   if (!blocklet) {
     throw new Error('blocklet should not be empty');
@@ -483,8 +488,12 @@ const startBlockletProcess = async (
       if (status === BlockletStatus.error) {
         throw new Error(`${processId} is not running within 5 seconds`);
       }
-
       logger.info('blocklet started', { processId, status });
+
+      // run hook
+      postStart(b, { env }).catch((err) => {
+        logger.error('blocklet post start failed', { processId, error: err });
+      });
     },
     { parallel: true }
   );
@@ -1223,6 +1232,72 @@ const ensureMeta = (meta, { name, did } = {}) => {
   return newMeta;
 };
 
+const getBlocklet = async ({
+  did,
+  dataDirs,
+  states,
+  e2eMode = false,
+  validateEnv = true,
+  throwOnNotExist = true,
+  ensureDirs = true,
+} = {}) => {
+  if (!did) {
+    throw new Error('Blocklet did does not exist');
+  }
+  if (!isValidDid(did)) {
+    throw new Error(`Blocklet did is invalid: ${did}`);
+  }
+
+  if (!dataDirs) {
+    throw new Error('dataDirs does not exist');
+  }
+
+  if (!states) {
+    throw new Error('states does not exist');
+  }
+
+  const blocklet = await states.blocklet.getBlocklet(did);
+  if (!blocklet) {
+    if (throwOnNotExist) {
+      throw new Error(`can not find blocklet in database by did ${did}`);
+    }
+    return null;
+  }
+
+  // app settings
+  const settings = await states.blockletExtras.getSettings(blocklet.meta.did);
+  blocklet.trustedPassports = get(settings, 'trustedPassports') || [];
+  blocklet.enablePassportIssuance = get(settings, 'enablePassportIssuance', true);
+  blocklet.settings = settings || {};
+
+  // app site
+  const sites = await states.site.getSites();
+  const domain = getBlockletDomainGroupName(blocklet.meta.did);
+  blocklet.site = (sites || []).find((x) => x.domain === domain);
+
+  await forEachBlocklet(blocklet, async (component, { id, level, ancestors }) => {
+    // component env
+    component.env = {
+      id,
+      name: getComponentName(component, ancestors),
+      processId: getComponentProcessId(component, ancestors),
+      ...getComponentDirs(component, {
+        dataDirs,
+        ensure: ensureDirs,
+        validate: validateEnv,
+        ancestors,
+        e2eMode: level === 0 ? e2eMode : false,
+      }),
+    };
+
+    // component config
+    const configs = await states.blockletExtras.getConfigs([...ancestors.map((x) => x.meta.did), component.meta.did]);
+    fillBlockletConfigs(component, configs);
+  });
+
+  return blocklet;
+};
+
 module.exports = {
   forEachBlocklet,
   getBlockletMetaFromUrl: (url) => getBlockletMetaFromUrl(url, { logger }),
@@ -1261,4 +1336,5 @@ module.exports = {
   needBlockletDownload,
   findAvailableDid,
   ensureMeta,
+  getBlocklet,
 };