@abtnode/core 1.16.8-beta-186fd5aa → 1.16.8-next-c66e39c7

package/lib/migrations/index.js

@@ -1,13 +1,55 @@
+/* eslint-disable no-continue */
 /* eslint-disable no-await-in-loop */
 const fs = require('fs');
 const path = require('path');
 const semver = require('semver');
 const uniqBy = require('lodash/uniqBy');
 const logger = require('@abtnode/logger')('@abtnode/core:migration');
+const {
+  doSchemaMigration,
+  doDataMigration,
+  getBlockletModels,
+  getServerModels,
+  getServiceModels,
+  getCertificateManagerModels,
+  createSequelize,
+} = require('@abtnode/models');
+const { getDbFilePath } = require('../util');
 
-const BACKUP_FILE_STATE_DB = 'state.json';
+const BACKUP_FILE_DB = 'server.db';
 const BACKUP_FILE_CONFIG = 'config.yml';
 
+const MODULES = ['certificate-manager'];
+const MAPPINGS = {
+  server: {
+    access_key: 'AccessKey',
+    'audit-log': 'AuditLog',
+    blocklet: 'Blocklet',
+    blocklet_extras: 'BlockletExtra',
+    cache: 'Cache',
+    migration: 'Migration',
+    node: 'Server',
+    notification: 'Notification',
+    routing_rule: 'Site',
+    session: 'Session',
+    user: 'User',
+    webhook: 'WebHook',
+  },
+  blocklet: {
+    user: 'User',
+    session: 'Session',
+    rbac: 'Rbac',
+  },
+  service: {
+    message: 'Message',
+  },
+  'certificate-manager': {
+    account: 'Account',
+    certificate: 'Certificate',
+    'http-challenge': 'HttpChallenge',
+  },
+};
+
 const getMigrationScripts = (scriptsDir) => {
   const files = fs.readdirSync(scriptsDir);
   const scripts = files
@@ -36,23 +78,17 @@ const getMigrationScripts = (scriptsDir) => {
   return sorted;
 };
 
-// TODO: enter upgrading mode
-const doBackup = async ({ states, dataDir, configFile, printInfo, printSuccess }) => {
+const doBackup = async ({ dataDir, configFile, printInfo, printSuccess }) => {
   printInfo('Backing up state db and config before migration...');
-  const data = {};
-  const keys = Object.keys(states);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const state = states[key];
-    data[key] = await state.asyncDB.find({});
-  }
 
   const backupDir = path.join(dataDir, 'migration', Date.now().toString());
   fs.mkdirSync(backupDir, { recursive: true });
 
-  const stateBackup = path.join(backupDir, BACKUP_FILE_STATE_DB);
-  fs.writeFileSync(stateBackup, JSON.stringify(data, null, 2));
-  if (configFile && fs.existsSync(configFile)) {
+  const dbFile = path.join(dataDir, 'core/server.db');
+  if (fs.existsSync(dbFile)) {
+    fs.copyFileSync(dbFile, path.join(backupDir, BACKUP_FILE_DB));
+  }
+  if (fs.existsSync(configFile)) {
     fs.copyFileSync(configFile, path.join(backupDir, BACKUP_FILE_CONFIG));
   }
 
@@ -60,47 +96,28 @@ const doBackup = async ({ states, dataDir, configFile, printInfo, printSuccess }
   return backupDir;
 };
 
-// TODO: exit upgrading mode
-const doRestore = async ({ states, configFile, backupPath, printInfo, printSuccess }) => {
+const doRestore = async ({ dataDir, configFile, backupPath, printInfo, printSuccess }) => {
   printInfo('Restoring when migration failed...');
 
-  const stateBackup = path.join(backupPath, BACKUP_FILE_STATE_DB);
+  const dbBackup = path.join(backupPath, BACKUP_FILE_DB);
   const configBackup = path.join(backupPath, BACKUP_FILE_CONFIG);
 
   // Validate backup
   if (fs.existsSync(backupPath) === false) {
     throw new Error(`Backup folder does not exist: ${backupPath}`);
   }
-  if (fs.existsSync(stateBackup) === false) {
-    throw new Error(`Backup file for state does not exist: ${stateBackup}`);
+  if (fs.existsSync(dbBackup) === false) {
+    throw new Error(`Backup file for state does not exist: ${dbBackup}`);
   }
   if (configFile && fs.existsSync(configBackup) === false) {
     throw new Error(`Backup file for config does not exist: ${configBackup}`);
   }
 
   // Restore state db
-  let backup = null;
-  try {
-    backup = JSON.parse(fs.readFileSync(stateBackup));
-  } catch (err) {
-    throw new Error(`Failed to read and parse backup file: ${stateBackup}, ${err.message}`);
-  }
-  const keys = Object.keys(states);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const state = states[key];
-    if (Array.isArray(backup[key])) {
-      await state.asyncDB.remove({}, { multi: true });
-      await state.asyncDB.insert(backup[key]);
-    } else {
-      throw new Error(`Invalid backup for state ${key}`);
-    }
-  }
+  fs.copyFileSync(dbBackup, path.join(dataDir, 'core/server.db'));
 
   // Restore config
-  if (configFile) {
-    fs.copyFileSync(configBackup, configFile);
-  }
+  fs.copyFileSync(configBackup, configFile);
 
   printSuccess('State db and config was successfully restored!');
 };
@@ -154,7 +171,7 @@ const runMigrationScripts = async ({
 
   let backupPath = null;
   try {
-    backupPath = await doBackup({ node, states, config, dataDir, configFile, printInfo, printSuccess, printError });
+    backupPath = await doBackup({ dataDir, configFile, printInfo, printSuccess });
   } catch (err) {
     printError(`Failed to backup state db due to ${err.message}, abort!`);
     return false;
@@ -177,7 +194,7 @@ const runMigrationScripts = async ({
       printError(`Failed to execute migration script: ${script}, error: ${err.message}`);
 
       try {
-        await doRestore({ node, states, config, configFile, dataDir, printInfo, printSuccess, printError, backupPath });
+        await doRestore({ configFile, dataDir, printInfo, printSuccess, backupPath });
       } catch (err2) {
         printError(`Failed to restore state db due to: ${err2.message}`);
       }
@@ -189,9 +206,142 @@ const runMigrationScripts = async ({
   return true;
 };
 
+const runSchemaMigrations = async ({
+  dataDir,
+  blocklets = [],
+  printInfo = console.info, // eslint-disable-line
+  printSuccess = console.info, // eslint-disable-line
+}) => {
+  // migrate server schema
+  let filePath = getDbFilePath(path.join(dataDir, 'core/server.db'));
+  await doSchemaMigration(filePath, 'server');
+  printSuccess(`Server schema successfully migrated: ${filePath}`);
+
+  // migrate service schema
+  filePath = getDbFilePath(path.join(dataDir, 'services/service.db'));
+  await doSchemaMigration(filePath, 'service');
+  printSuccess(`Service schema successfully migrated: ${filePath}`);
+
+  // migrate blocklet schema
+  for (let i = 0; i < blocklets.length; i++) {
+    const blocklet = blocklets[i];
+    const env = blocklet.environments.find((x) => x.key === 'BLOCKLET_DATA_DIR');
+    if (env) {
+      filePath = getDbFilePath(path.join(env.value, 'blocklet.db'));
+      await doSchemaMigration(filePath, 'blocklet');
+      printSuccess(`Blocklet schema successfully migrated: ${blocklet.appPid}: ${filePath}`);
+    } else {
+      printInfo(`Skip migrate schema for blocklet: ${blocklet.appPid}`);
+    }
+  }
+
+  // migrate certificate manager schema
+  for (let i = 0; i < MODULES.length; i++) {
+    filePath = getDbFilePath(path.join(dataDir, `modules/${MODULES[i]}/module.db`));
+    await doSchemaMigration(filePath, MODULES[i]);
+    printSuccess(`${MODULES[i]} schema successfully migrated: ${filePath}`);
+  }
+};
+
+const runDataMigrations = async ({
+  dataDir,
+  blocklets = [],
+  printInfo = console.info, // eslint-disable-line
+  printSuccess = console.info, // eslint-disable-line
+  printError = console.error,
+}) => {
+  // migrate server data
+  await doDataMigration({
+    srcDir: path.join(dataDir, 'core'),
+    dbFile: path.join(dataDir, 'core/server.db'),
+    mapping: MAPPINGS.server,
+    models: getServerModels(),
+    printInfo,
+    printError,
+    printSuccess,
+  });
+  printSuccess('Server data successfully migrated');
+
+  // migrate service data
+  await doDataMigration({
+    srcDir: path.join(dataDir, 'services'),
+    dbFile: path.join(dataDir, 'services/service.db'),
+    models: getServiceModels(),
+    mapping: MAPPINGS.service,
+    printInfo,
+    printError,
+    printSuccess,
+  });
+  printSuccess('Service data successfully migrated');
+
+  // migrate blocklet data
+  for (let i = 0; i < blocklets.length; i++) {
+    const blocklet = blocklets[i];
+    const env = blocklet.environments.find((x) => x.key === 'BLOCKLET_DATA_DIR');
+    if (env) {
+      await doDataMigration({
+        srcDir: path.join(env.value),
+        dbFile: path.join(env.value, 'blocklet.db'),
+        models: getBlockletModels(),
+        mapping: MAPPINGS.blocklet,
+        printInfo,
+        printError,
+        printSuccess,
+      });
+      printSuccess(`Blocklet data successfully migrated: ${blocklet.appPid}`);
+    } else {
+      printInfo(`Skip migrate data for blocklet: ${blocklet.appPid}`);
+    }
+  }
+
+  // migrate certificate manager schema
+  for (let i = 0; i < MODULES.length; i++) {
+    await doDataMigration({
+      srcDir: path.join(dataDir, `modules/${MODULES[i]}/db`),
+      dbFile: path.join(dataDir, `modules/${MODULES[i]}/module.db`),
+      models: getCertificateManagerModels(),
+      mapping: MAPPINGS[MODULES[i]],
+      printInfo,
+      printError,
+      printSuccess,
+    });
+    printSuccess(`${MODULES[i]} data successfully migrated`);
+  }
+};
+
+const closeDatabaseConnections = async ({
+  dataDir,
+  blocklets = [],
+  printInfo = console.info, // eslint-disable-line
+}) => {
+  const dataFiles = [
+    getDbFilePath(path.join(dataDir, 'core/server.db')),
+    getDbFilePath(path.join(dataDir, 'services/service.db')),
+  ];
+  for (let i = 0; i < blocklets.length; i++) {
+    const blocklet = blocklets[i];
+    const env = blocklet.environments.find((x) => x.key === 'BLOCKLET_DATA_DIR');
+    if (env) {
+      dataFiles.push(getDbFilePath(path.join(env.value, 'blocklet.db')));
+    }
+  }
+  for (let i = 0; i < MODULES.length; i++) {
+    dataFiles.push(getDbFilePath(path.join(dataDir, `modules/${MODULES[i]}/module.db`)));
+  }
+
+  const connections = dataFiles.map((x) => createSequelize(x));
+  connections.forEach((x) => {
+    x.close();
+    printInfo(`Closed database connection: ${x}`);
+  });
+};
+
 module.exports = {
   getMigrationScripts,
   runMigrationScripts,
+  runSchemaMigrations,
+  runDataMigrations,
+  closeDatabaseConnections,
   doBackup,
   doRestore,
 };

package/lib/monitor/node-runtime-monitor.js

@@ -2,7 +2,7 @@ const EventEmitter = require('events');
 const pick = require('lodash/pick');
 const cloneDeep = require('lodash/cloneDeep');
 
-const { PROCESS_NAME_DAEMON, PROCESS_NAME_PROXY, PROCESS_NAME_SERVICE, EVENTS } = require('@abtnode/constant');
+const { PROCESS_NAME_DAEMON, PROCESS_NAME_SERVICE, EVENTS } = require('@abtnode/constant');
 const defaultLogger = require('@abtnode/logger')('@abtnode/util:node-runtime-info');
 const pm2 = require('@abtnode/util/lib/async-pm2');
 
@@ -45,7 +45,6 @@ const getProcessInfo = (processId, { returnList } = {}) =>
 //   mem: number;
 //   daemonMem: number;
 //   serviceMem: number;
-//   dbMem: number;
 // };
 
 // type History = Array<NodeHistoryItem>;
@@ -57,7 +56,6 @@ const getProcessInfo = (processId, { returnList } = {}) =>
 //   disks: [];
 //   daemon: RuntimeInfo
 //   service: ServiceRuntimeInfo
-//   db: RuntimeInfo
 
 // type MonitorData = {
 //   realtime: Realtime;
@@ -72,7 +70,6 @@ const DEFAULT_DATA = {
     disks: [],
     daemon: {},
     service: {},
-    db: {},
   },
   history: [],
 };
@@ -123,13 +120,8 @@ class NodeRuntimeMonitor extends EventEmitter {
             this.logger.error(`failed to get daemon info: ${error.message}`);
           })
         : Promise.resolve(),
-      process.env.NODE_ENV !== 'development'
-        ? getProcessInfo(PROCESS_NAME_PROXY).catch((error) => {
-            this.logger.error(`failed to get db info: ${error.message}`);
-          })
-        : Promise.resolve(),
     ])
-      .then(([{ value: sysInfo }, { value: serviceInfos }, { value: daemonInfo }, { value: dbInfo }]) => {
+      .then(([{ value: sysInfo }, { value: serviceInfos }, { value: daemonInfo }]) => {
         this.inProgress = false;
 
         const historyItem = {
@@ -138,7 +130,6 @@ class NodeRuntimeMonitor extends EventEmitter {
           mem: 0,
           daemonMem: 0,
           serviceMem: 0,
-          dbMem: 0,
         };
 
         if (sysInfo) {
@@ -186,24 +177,6 @@ class NodeRuntimeMonitor extends EventEmitter {
           this.data.realtime.daemon = {};
         }
 
-        if (dbInfo) {
-          const proc = dbInfo;
-
-          const runtimeInfo = {
-            pid: proc.pid,
-            uptime: proc.pm2_env ? +new Date() - Number(proc.pm2_env.pm_uptime) : 0,
-            memoryUsage: proc.monit.memory,
-            cpuUsage: proc.monit.cpu,
-            status: proc.pm2_env ? proc.pm2_env.status : null,
-          };
-
-          this.data.realtime.db = runtimeInfo;
-
-          historyItem.dbMem = runtimeInfo.memoryUsage;
-        } else {
-          this.data.realtime.db = {};
-        }
-
         this.logger.info('server runtime info', historyItem);
 
         this._push(historyItem);

package/lib/router/helper.js

@@ -836,7 +836,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     domainAliases.push(...dashboardAliasDomains);
 
     try {
-      const result = await siteState.update({ _id: dashboardSite.id }, { $set: { domainAliases } });
+      const result = await siteState.update({ id: dashboardSite.id }, { $set: { domainAliases } });
 
       updatedResult.push(result);
     } catch (error) {
@@ -992,7 +992,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    *    add rules in wellknown site
    * This function should be called after `ensureDashboardRouting`
    *
-   * @returns {boolean} if routing changed
+   * @returns {Promise<boolean>} if routing changed
    */
   const ensureBlockletRouting = async (blocklet, context = {}) => {
     const nodeInfo = await nodeState.read();
@@ -1008,7 +1008,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    * remove custom rules of blocklet in old interface does not exist
    * update custom rules of blocklet
    *
-   * @returns {boolean} if routing changed
+   * @returns {Promise<boolean>} if routing changed
    */
   const ensureBlockletCustomRouting = async (blocklet) => {
     // Only one blocklet web interface can be declared since router 2.0
@@ -1053,7 +1053,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         try {
           // eslint-disable-next-line no-await-in-loop
           await states.site.update(
-            { _id: site.id },
+            { id: site.id },
             { $set: { rules: site.rules.filter((x) => rulesToRemove.includes(x.id) === false) } }
           );
           changed = true;
@@ -1075,7 +1075,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
    * Update routing for blocklet when blocklet is upgraded
    * This function should be called after `ensureDashboardRouting`
    *
-   * @returns {boolean} if routing changed
+   * @returns {Promise<boolean>} if routing changed
    */
   const ensureBlockletRoutingForUpgrade = async (blocklet, context = {}) => {
     await routerManager.deleteRoutingRulesItemByDid(
@@ -1092,7 +1092,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   /**
    * Remove routing for blocklet
    *
-   * @returns {boolean} if routing changed
+   * @returns {Promise<boolean>} if routing changed
    */
   const removeBlockletRouting = async (blocklet, context = {}) => {
     const ruleChanged = await routerManager.deleteRoutingRulesItemByDid({ did: blocklet.meta.did }, context);

package/lib/router/manager.js

@@ -134,7 +134,7 @@ class RouterManager extends EventEmitter {
 
   // eslint-disable-next-line no-unused-vars
   async deleteRoutingSite({ id }, context = {}) {
-    const site = await states.site.findOne({ _id: id });
+    const site = await states.site.findOne({ id });
     if ([DOMAIN_FOR_IP_SITE, DOMAIN_FOR_DEFAULT_SITE].includes(site.domain)) {
       // eslint-disable-next-line quotes
       throw new Error("Can not delete this site because it's protected");
@@ -143,7 +143,7 @@ class RouterManager extends EventEmitter {
     // validate router config
     await this.validateRouterConfig('deleteRoutingSite', { id });
 
-    const removedSiteCount = await states.site.remove({ _id: id });
+    const removedSiteCount = await states.site.remove({ id });
 
     if (removedSiteCount === 0) {
       throw new Error(`remove site ${id} failed`);
@@ -156,7 +156,7 @@ class RouterManager extends EventEmitter {
   // eslint-disable-next-line no-unused-vars
   async updateRoutingSite(params, context = {}) {
     const site = await validateUpdateSite(params, context);
-    const existed = await states.site.findOne({ _id: site.id });
+    const existed = await states.site.findOne({ id: site.id });
     if (!existed) {
       throw new Error('Can not update non-existing site');
     }
@@ -169,30 +169,27 @@ class RouterManager extends EventEmitter {
 
     if (site.domain) {
       const newDomain = site.domain;
-      const ruleCountInDB = await states.site.count({
-        $or: [{ domain: newDomain }, { domainAliases: newDomain }, { 'domainAliases.value': newDomain }],
-      });
-
-      if (ruleCountInDB > 0) {
+      const exist = await states.site.domainExists(newDomain);
+      if (exist) {
         throw new Error(`Site ${newDomain} already exists`);
       }
 
       updateSet.domain = newDomain;
     }
 
-    const updated = await states.site.update({ _id: site.id }, { $set: updateSet }, { multi: false, upsert: false });
+    const updated = await states.site.update({ id: site.id }, { $set: updateSet });
 
     logger.info('router.site.updated', { site, updated });
     this.emit('router.site.updated', site.id);
 
-    const dbSite = await states.site.findOne({ _id: site.id });
+    const dbSite = await states.site.findOne({ id: site.id });
     await attachRuntimeDomainAliases({ sites: dbSite, context, node: states.node });
     return dbSite;
   }
 
   async addDomainAlias({ id, domainAlias: tmpAlias, force }, context = {}) {
     const domainAlias = await validateAddDomainAlias(tmpAlias, context);
-    const dbSite = await states.site.findOne({ _id: id });
+    const dbSite = await states.site.findOne({ id });
     if (!dbSite) {
       throw new Error(`site ${id} does not exist`);
     }
@@ -211,10 +208,7 @@ class RouterManager extends EventEmitter {
     }
 
     // check domain exists in site alias domain
-    const aliasDomainSite = await states.site.findOne({
-      $or: [{ domainAliases: domainAlias }, { 'domainAliases.value': domainAlias }],
-    });
-
+    const aliasDomainSite = await states.site.findByDomainAlias(domainAlias);
     if (aliasDomainSite) {
       if (!force) {
         throw new Error(`${domainAlias} already exists`);
@@ -223,13 +217,14 @@ class RouterManager extends EventEmitter {
       }
     }
 
+    const doc = await states.site.findOne({ id });
     const updateResult = await states.site.update(
-      { _id: id },
-      { $push: { domainAliases: { value: domainAlias, isProtected: false } } }
+      { id },
+      { $set: { domainAliases: [...doc.domainAliases, { value: domainAlias, isProtected: false }] } }
     );
     logger.debug('add domain alias update result', { id, updateResult, domainAlias });
 
-    const newSite = await states.site.findOne({ _id: id });
+    const newSite = await states.site.findOne({ id });
     await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 
     return newSite;
@@ -237,7 +232,7 @@ class RouterManager extends EventEmitter {
 
   async deleteDomainAlias({ id, domainAlias: tmpAlias }, context = {}) {
     const domainAlias = await validateAddDomainAlias(tmpAlias, context);
-    const dbSite = await states.site.findOne({ _id: id });
+    const dbSite = await states.site.findOne({ id });
     if (!dbSite) {
       throw new Error(`site ${id} does not exist`);
     }
@@ -250,7 +245,7 @@ class RouterManager extends EventEmitter {
       return toLower(x.value) !== domainAlias;
     });
 
-    const updateResult = await states.site.update({ _id: id }, { $set: { domainAliases: dbSite.domainAliases } });
+    const updateResult = await states.site.update({ id }, { $set: { domainAliases: dbSite.domainAliases } });
     logger.debug('remove domain alias update result', { id, updateResult, domainAlias });
 
     await attachRuntimeDomainAliases({ sites: dbSite, context, node: states.node });
@@ -268,7 +263,7 @@ class RouterManager extends EventEmitter {
       rule.from.pathPrefix = tempRule.from.pathPrefix;
     }
 
-    const dbSite = await states.site.findOne({ _id: id });
+    const dbSite = await states.site.findOne({ id });
     if (!dbSite) {
       throw new Error(`site ${id} does not exist`);
     }
@@ -295,7 +290,7 @@ class RouterManager extends EventEmitter {
       await states.site.addRuleToSite(id, x);
     }
 
-    const newSite = await states.site.findOne({ _id: id });
+    const newSite = await states.site.findOne({ id });
     await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 
     this.emit('router.rule.created', newSite);
@@ -312,8 +307,11 @@ class RouterManager extends EventEmitter {
       rule.from.pathPrefix = tmpRule.from.pathPrefix;
     }
 
-    const dbSite = await states.site.findOne({ _id: id, 'rules.id': rule.id });
+    const dbSite = await states.site.findOne({ id });
     if (!dbSite) {
+      throw new Error(`site ${id} does not exist`);
+    }
+    if (!dbSite.rules.find((x) => x.id === rule.id)) {
       throw new Error(`site ${id}, rule ${rule.id} does not exist`);
     }
 
@@ -344,9 +342,9 @@ class RouterManager extends EventEmitter {
       ...(await this.getRulesForMutation(rule)),
     ];
 
-    const updateResult = await states.site.update({ _id: id }, { $set: { rules: newRules } });
+    const updateResult = await states.site.update({ id }, { $set: { rules: newRules } });
     logger.info('update result', { updateResult });
-    const newSite = await states.site.findOne({ _id: id });
+    const newSite = await states.site.findOne({ id });
 
     await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 
@@ -356,7 +354,7 @@ class RouterManager extends EventEmitter {
   }
 
   async deleteRoutingRule({ id, ruleId }, context = {}) {
-    const tmpRule = await states.site.findOne({ _id: id, 'rules.id': ruleId });
+    const tmpRule = await states.site.getSiteByRuleId(id, ruleId);
     if (!tmpRule) {
       throw new Error(`rule item ${ruleId} in rule ${id} does not exist`);
     }
@@ -371,11 +369,14 @@ class RouterManager extends EventEmitter {
     await this.validateRouterConfig('deleteRoutingRule', { id, ruleId });
 
     // 只要有匹配到的查询条件，不管是否删除成功都不会返回 0，所以这里没用 update 的返回值
-    await states.site.update({ _id: id }, { $pull: { rules: { groupId: ruleId } } });
-    await states.site.update({ _id: id }, { $pull: { rules: { id: ruleId } } }); // for legacy compatible
+    const doc = await states.site.findOne({ id });
+    if (doc.rules.some((x) => x.id === ruleId || x.groupId === ruleId)) {
+      const newRules = doc.rules.filter((x) => x.id !== ruleId && x.groupId !== ruleId);
+      await states.site.update({ id }, { $set: { rules: newRules } });
+    }
 
     logger.info('router.rule.removed', { id, ruleId });
-    const newSite = await states.site.findOne({ _id: id });
+    const newSite = await states.site.findOne({ id });
 
     await attachRuntimeDomainAliases({ sites: newSite, context, node: states.node });
 
@@ -410,9 +411,8 @@ class RouterManager extends EventEmitter {
   // eslint-disable-next-line no-unused-vars
   async deleteRoutingRulesItemByDid({ did, ruleFilter }, context = {}) {
     logger.info('deleteRoutingRulesItemByDid.did', { did });
-    const sites = await states.site.find({ 'rules.to.did': did });
-    if (!Array.isArray(sites)) {
-      logger.warn('deleteRoutingRulesItemByDid sites is not an array');
+    const sites = await states.site.getSitesByBlocklet(did);
+    if (!sites.length) {
       return false;
     }
 
@@ -429,7 +429,7 @@ class RouterManager extends EventEmitter {
         return false;
       });
 
-      tasks.push(states.site.update({ _id: site._id }, { $set: { rules: site.rules } })); // eslint-disable-line no-underscore-dangle
+      tasks.push(states.site.update({ id: site.id }, { $set: { rules: site.rules } })); // eslint-disable-line no-underscore-dangle
     }
 
     const result = await Promise.all(tasks);
@@ -461,10 +461,9 @@ class RouterManager extends EventEmitter {
   // eslint-disable-next-line consistent-return
   async repopulateRouting({ sites }) {
     if (Array.isArray(sites) && sites.length) {
-      const result = await states.site.remove({}, { multi: true });
+      const result = await states.site.remove({});
       logger.info('routing rules all removed', { result });
-
-      await states.site.insert(sites.map((x) => ({ ...x, _id: x.id })));
+      await states.site.insertMany(sites.map((x) => ({ ...x, id: x.id })));
     }
   }
 

package/lib/states/access-key.js

@@ -18,19 +18,10 @@ const validatePassport = (passport) => {
 
 const getUserName = (context) => get(context, 'user.fullName', '');
 
+/**
+ * @extends BaseState<import('@abtnode/models').AccessKeyState>
+ */
 class AccessKeyState extends BaseState {
-  constructor(baseDir, config = {}) {
-    super(baseDir, { filename: 'access_key.db', ...config });
-
-    this.onReady(() => {
-      this.ensureIndex({ fieldName: 'accessKeyId', unique: true }, (error) => {
-        if (error) {
-          logger.error('ensure unique index failed', { error });
-        }
-      });
-    });
-  }
-
   async create(input, context) {
     const { remark, passport, tag } = input || {};
 
@@ -62,14 +53,6 @@ class AccessKeyState extends BaseState {
     };
   }
 
-  async getAccessKeyByTag({ tag } = {}) {
-    if (!tag) {
-      throw new Error('tag should not be empty');
-    }
-
-    return this.findOne({ tag });
-  }
-
   // eslint-disable-next-line no-unused-vars
   async list(params, context) {
     const res = await this.paginate({}, { createdAt: -1 }, { pageSize: 100 });