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

package/lib/states/blocklet.js

@@ -28,7 +28,7 @@ const { validateBlockletMeta } = require('../util/blocklet');
 const lock = new Lock('blocklet-port-assign-lock');
 
 const isHex = (str) => /^0x[0-9a-f]+$/i.test(str);
-const getMaxPort = (ports = {}) => Math.max(Object.values(ports).map(Number));
+const getMaxPort = (ports = {}) => Math.max(...Object.values(ports).map(Number));
 
 // structV1Did is just for migration purpose and should be removed in the future
 const getConditions = (did) => [{ 'meta.did': did }, { appDid: did }, { appPid: did }, { structV1Did: did }];
@@ -133,121 +133,75 @@ const fixChildren = (children) => {
 //   [name: string]: Number; // name is in meta.interfaces[].port
 // };
 
+/**
+ * @extends BaseState<import('@abtnode/models').BlockletState>
+ */
 class BlockletState extends BaseState {
-  /**
-   * Creates an instance of BlockletState
-   * @param {string} baseDir
-   * @param {object} config
-   * @param {string} config.blockletPort - from which port to start new blocklets
-   * @memberof BlockletState
-   */
-  constructor(baseDir, config = {}) {
-    super(baseDir, { filename: 'blocklet.db', ...config });
-
+  constructor(model, config = {}) {
+    super(model, config);
     this.defaultPort = config.blockletPort || 5555;
+    // @didMap: { [did: string]: metaDid: string }
+    this.didMap = new Map();
   }
 
-  getBlocklet(did, { decryptSk = true } = {}) {
-    return new Promise((resolve, reject) => {
-      if (!did) {
-        resolve(null);
-      }
-
-      this.findOne({ $or: getConditions(did) }, (err, doc) => {
-        if (err) {
-          return reject(err);
-        }
+  async getBlocklet(did, { decryptSk = true } = {}) {
+    if (!did) {
+      return null;
+    }
 
-        return resolve(doc ? formatBlocklet(doc, 'onRead', decryptSk ? this.config.dek : null) : null);
-      });
-    });
+    const doc = await this.findOne({ $or: getConditions(did) });
+    return doc ? formatBlocklet(doc, 'onRead', decryptSk ? this.config.dek : null) : null;
   }
 
-  getBlockletMetaDid(did) {
-    return new Promise((resolve, reject) => {
-      if (!did) {
-        resolve(null);
-      }
+  async getBlockletMetaDid(did) {
+    if (this.didMap.has(did)) {
+      return this.didMap.get(did);
+    }
 
-      this.findOne({ $or: getConditions(did) }, (err, doc) => {
-        if (err) {
-          return reject(err);
-        }
+    const doc = await this.getBlocklet(did);
+    if (doc?.meta?.did) {
+      this.didMap.set(did, doc.meta.did);
+      return doc.meta.did;
+    }
 
-        return resolve(doc ? doc.meta.did : null);
-      });
-    });
+    return null;
   }
 
   async getBlockletStatus(did) {
-    return new Promise((resolve, reject) => {
-      if (!did) {
-        resolve(null);
-      }
-
-      this.findOne({ $or: getConditions(did) }, { status: 1 }, (err, doc) => {
-        if (err) {
-          return reject(err);
-        }
-
-        return resolve(doc ? doc.status : null);
-      });
-    });
+    const doc = await this.getBlocklet(did);
+    return doc ? doc.status : null;
   }
 
-  hasBlocklet(did) {
-    return new Promise((resolve, reject) => {
-      if (!did) {
-        resolve(false);
-      }
-
-      this.count({ $or: getConditions(did) }, (err, count) => {
-        if (err) {
-          return reject(err);
-        }
+  async hasBlocklet(did) {
+    if (!did) {
+      return false;
+    }
 
-        return resolve(!!count);
-      });
-    });
+    const count = await this.count({ $or: getConditions(did) });
+    return count > 0;
   }
 
-  getBlocklets(query = {}, projection) {
-    return new Promise((resolve, reject) => {
-      this.cursor(query)
-        .projection(projection)
-        .sort({ createdAt: -1 })
-        .exec((err, docs = []) => {
-          if (err) {
-            return reject(err);
-          }
-
-          return resolve(docs.filter(Boolean).map((doc) => formatBlocklet(doc, 'onRead', this.config.dek)));
-        });
-    });
+  async getBlocklets(query = {}, projection = {}, sort = { createdAt: -1 }) {
+    const docs = await this.find(query, projection, sort);
+    return docs.filter(Boolean).map((doc) => formatBlocklet(doc, 'onRead', this.config.dek));
   }
 
-  deleteBlocklet(did) {
-    return this.getBlocklet(did).then(
-      (doc) =>
-        // eslint-disable-next-line consistent-return
-        new Promise((resolve, reject) => {
-          if (!doc) {
-            return reject(new Error(`Try to remove non-existing blocklet ${did}`));
-          }
+  async deleteBlocklet(did) {
+    const doc = await this.getBlocklet(did);
+    if (!doc) {
+      throw new Error(`Try to remove non-existing blocklet ${did}`);
+    }
 
-          this.remove({ _id: doc._id }, (err) => {
-            if (err) {
-              return reject(err);
-            }
+    await this.remove({ id: doc.id });
 
-            this.emit('remove', doc);
-            return resolve(formatBlocklet(doc, 'onRead', this.config.dek));
-          });
-        })
-    );
+    this.didMap.delete(doc.meta?.did);
+    this.didMap.delete(doc.appDid);
+
+    this.emit('remove', doc);
+    return formatBlocklet(doc, 'onRead', this.config.dek);
   }
 
-  addBlocklet({
+  async addBlocklet({
     meta,
     source = BlockletSource.registry,
     status = BlockletStatus.added,
@@ -261,139 +215,111 @@ class BlockletState extends BaseState {
     externalSk = true,
     externalSkSource = '',
   } = {}) {
-    return this.getBlocklet(meta.did).then(
-      (exist) =>
-        new Promise(async (resolve, reject) => {
-          if (exist) {
-            reject(new Error('Blocklet already added'));
-            return;
-          }
+    let doc = await this.getBlocklet(meta.did);
+    if (doc) {
+      throw new Error('Blocklet already added');
+    }
 
-          try {
-            fixPerson(meta);
-            fixInterfaces(meta);
-            let sanitized = validateBlockletMeta(meta);
-            // bundle info
-            sanitized = ensureMeta(sanitized);
-            sanitized = omit(sanitized, ['htmlAst']);
-
-            // get ports
-            await lock.acquire();
-
-            const ports = await this.getBlockletPorts({ interfaces: sanitized.interfaces || [] });
-
-            const children = await this.fillChildrenPorts(rawChildren, {
-              defaultPort: getMaxPort(ports),
-            });
-
-            fixChildren(children);
-
-            const data = {
-              appDid: null, // will updated later when updating blocklet environments
-              appPid,
-              mode,
-              meta: sanitized,
-              status,
-              source,
-              deployedFrom,
-              ports,
-              environments: [],
-              children,
-              migratedFrom,
-              externalSk,
-              externalSkSource,
-              structVersion: APP_STRUCT_VERSION,
-            };
-
-            // add to db
-            this.insert(data, (err, doc) => {
-              lock.release();
-              if (err) {
-                return reject(err);
-              }
+    try {
+      fixPerson(meta);
+      fixInterfaces(meta);
+      let sanitized = validateBlockletMeta(meta);
+      // bundle info
+      sanitized = ensureMeta(sanitized);
+      sanitized = omit(sanitized, ['htmlAst']);
+
+      // get ports
+      await lock.acquire();
+      const ports = await this.getBlockletPorts({ interfaces: sanitized.interfaces || [] });
+      const children = await this.fillChildrenPorts(rawChildren, { defaultPort: getMaxPort(ports) });
+      fixChildren(children);
+
+      // add to db
+      doc = await this.insert({
+        appDid: appPid, // will updated later when updating blocklet environments
+        appPid,
+        mode,
+        meta: sanitized,
+        status,
+        source,
+        deployedFrom,
+        ports,
+        environments: [],
+        children,
+        migratedFrom,
+        externalSk,
+        externalSkSource,
+        structVersion: APP_STRUCT_VERSION,
+      });
 
-              this.emit('add', doc);
-              return resolve(doc);
-            });
-          } catch (err) {
-            lock.release();
-            reject(err);
-          }
-        })
-    );
+      doc = await this.findOne({ id: doc.id });
+
+      lock.release();
+      this.emit('add', doc);
+
+      return doc;
+    } catch (err) {
+      lock.release();
+      throw err;
+    }
   }
 
   // FIXME: 这个接口比较危险，可能会修改一些本不应该修改的字段，后续需要考虑改进
-  updateBlocklet(did, updates) {
-    return this.getBlocklet(did).then(
-      (doc) =>
-        new Promise(async (resolve, reject) => {
-          if (!doc) {
-            reject(new Error('Blocklet does not exist'));
-            return;
-          }
+  async updateBlocklet(did, updates) {
+    const doc = await this.getBlocklet(did);
+    if (!doc) {
+      throw new Error('Blocklet does not exist');
+    }
 
-          try {
-            const formatted = formatBlocklet(cloneDeep(updates), 'onUpdate', this.config.dek);
-            const newDoc = await this.updateById(doc._id, { $set: formatted });
-            resolve(newDoc);
-          } catch (err) {
-            reject(err);
-          }
-        })
-    );
+    const formatted = formatBlocklet(cloneDeep(updates), 'onUpdate', this.config.dek);
+    const [, [updated]] = await this.update({ id: doc.id }, { $set: formatted });
+    return updated;
   }
 
-  upgradeBlocklet({ meta, source, deployedFrom = '', children } = {}) {
-    return this.getBlocklet(meta.did).then(
-      (doc) =>
-        // eslint-disable-next-line no-async-promise-executor
-        new Promise(async (resolve, reject) => {
-          if (!doc) {
-            reject(new Error('Blocklet does not exist'));
-            return;
-          }
+  async upgradeBlocklet({ meta, source, deployedFrom = '', children } = {}) {
+    const doc = await this.getBlocklet(meta.did);
+    if (!doc) {
+      throw new Error('Blocklet does not exist');
+    }
 
-          try {
-            fixPerson(meta);
-            fixInterfaces(meta);
-            const sanitized = validateBlockletMeta(meta);
-
-            // get ports
-            await lock.acquire();
-
-            const ports = await this.getBlockletPorts({
-              interfaces: sanitized.interfaces || [],
-              skipOccupiedCheckPorts: getExternalPortsFromMeta(doc.meta),
-            });
-            Object.keys(ports).forEach((p) => {
-              ports[p] = doc.ports[p] || ports[p];
-            });
-
-            // fill
-            logger.info('Fill children ports when when upgrading blocklet', { name: doc.meta.name, did: doc.meta.did });
-            await this.fillChildrenPorts(children, { oldChildren: doc.children, defaultPort: getMaxPort(ports) });
-
-            fixChildren(children);
-
-            // add to db
-            const newDoc = await this.updateBlocklet(meta.did, {
-              meta: omit(sanitized, ['htmlAst']),
-              source,
-              deployedFrom,
-              children,
-              ports,
-            });
-            lock.release();
-
-            this.emit('upgrade', newDoc);
-            resolve(newDoc);
-          } catch (err) {
-            lock.release();
-            reject(err);
-          }
-        })
-    );
+    try {
+      fixPerson(meta);
+      fixInterfaces(meta);
+      const sanitized = validateBlockletMeta(meta);
+
+      // get ports
+      await lock.acquire();
+
+      const ports = await this.getBlockletPorts({
+        interfaces: sanitized.interfaces || [],
+        skipOccupiedCheckPorts: getExternalPortsFromMeta(doc.meta),
+      });
+      Object.keys(ports).forEach((p) => {
+        ports[p] = doc.ports[p] || ports[p];
+      });
+
+      // fill
+      logger.info('Fill children ports when when upgrading blocklet', { name: doc.meta.name, did: doc.meta.did });
+      await this.fillChildrenPorts(children, { oldChildren: doc.children, defaultPort: getMaxPort(ports) });
+
+      fixChildren(children);
+
+      // add to db
+      const newDoc = await this.updateBlocklet(meta.did, {
+        meta: omit(sanitized, ['htmlAst']),
+        source,
+        deployedFrom,
+        children,
+        ports,
+      });
+      lock.release();
+
+      this.emit('upgrade', newDoc);
+      return newDoc;
+    } catch (err) {
+      lock.release();
+      throw err;
+    }
   }
 
   async getBlockletPorts({
@@ -404,24 +330,24 @@ class BlockletState extends BaseState {
     defaultPort = 0,
   } = {}) {
     try {
-      const blocklets = await this.getBlocklets({}, { port: 1, ports: 1, 'meta.interfaces': 1, children: 1 });
+      const blocklets = await this.getBlocklets({}, { port: 1, ports: 1, meta: 1, children: 1 });
 
       const occupiedExternalPorts = new Map();
       const occupiedInternalPorts = new Map();
 
       const calcPortsFromBlocklet = (blocklet) => {
-        occupiedInternalPorts.set(Number(blocklet.port));
+        occupiedInternalPorts.set(Number(blocklet.port), true);
 
         if (blocklet.ports && typeof blocklet.ports === 'object') {
           Object.keys(blocklet.ports).forEach((key) => {
-            occupiedInternalPorts.set(Number(blocklet.ports[key]));
+            occupiedInternalPorts.set(Number(blocklet.ports[key]), true);
           });
         }
 
         if (Array.isArray(blocklet.meta.interfaces)) {
           blocklet.meta.interfaces.forEach((x) => {
             if (x.port && x.port.external) {
-              occupiedExternalPorts.set(Number(x.port.external));
+              occupiedExternalPorts.set(Number(x.port.external), true);
             }
           });
         }
@@ -566,7 +492,7 @@ class BlockletState extends BaseState {
       return formatBlocklet(doc, 'onRead', this.config.dek);
     }
 
-    const updates = { status, startedAt: undefined, stoppedAt: undefined };
+    const updates = { status, startedAt: null, stoppedAt: null };
     if (status === BlockletStatus.running) {
       updates.startedAt = new Date();
     }

package/lib/states/cache.js

@@ -1,31 +1,13 @@
-const logger = require('@abtnode/logger')('@abtnode/core:states:cache');
 const BaseState = require('./base');
 
 /**
  * This db is used to save arbitrary cached data.
+ * @extends BaseState<import('@abtnode/models').CacheState>
  */
 class CacheState extends BaseState {
-  constructor(baseDir, config = {}) {
-    super(baseDir, { filename: 'cache.db', ...config });
-
-    this.onReady(() => {
-      this.ensureIndex({ fieldName: 'key', unique: true }, (error) => {
-        if (error) {
-          logger.error('ensure index failed', { error });
-        }
-      });
-    });
-  }
-
   async set(key, value) {
-    const [, { value: res }] = await this.update(
-      { key },
-      { $set: { value } },
-      {
-        upsert: true,
-      }
-    );
-    return res;
+    const doc = await this.upsert({ key }, { value });
+    return doc.value;
   }
 
   async get(key) {

package/lib/states/connect-account.js

@@ -0,0 +1,8 @@
+const BaseState = require('./base');
+
+/**
+ * @extends BaseState<import('@abtnode/models').ConnectedAccountState>
+ */
+class ConnectedAccount extends BaseState {}
+
+module.exports = ConnectedAccount;

package/lib/states/index.js

@@ -1,6 +1,7 @@
-const stateFactory = require('@abtnode/db/lib/factory');
+const path = require('path');
+const { createSequelize, createStateFactory, getServerModels, setupModels } = require('@abtnode/models');
+
 const NodeState = require('./node');
-const ChallengeState = require('./challenge');
 const BlockletState = require('./blocklet');
 const NotificationState = require('./notification');
 const SiteState = require('./site');
@@ -11,22 +12,31 @@ const SessionState = require('./session');
 const ExtrasState = require('./blocklet-extras');
 const CacheState = require('./cache');
 const AuditLogState = require('./audit-log');
+const JobState = require('./job');
 const BackupState = require('./backup');
+const { getDbFilePath } = require('../util');
+
+const models = getServerModels();
+
+const init = (dataDirs, config = {}) => {
+  const dbPath = getDbFilePath(path.join(dataDirs.core, 'server.db'));
+  const sequelize = createSequelize(dbPath);
+  setupModels(models, sequelize);
+  console.info(`Init server states in ${dbPath}`); // eslint-disable-line
 
-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);
-  const backupState = new BackupState(dataDirs.core, config);
+  const notificationState = new NotificationState(models.Notification, config);
+  const nodeState = new NodeState(models.Server, config, dataDirs, notificationState);
+  const blockletState = new BlockletState(models.Blocklet, config);
+  const siteState = new SiteState(models.Site, config);
+  const accessKeyState = new AccessKeyState(models.AccessKey, config);
+  const webhookState = new WebhookState(models.WebHook, config);
+  const migrationState = new MigrationState(models.Migration, config);
+  const sessionState = new SessionState(models.Session, config);
+  const extrasState = new ExtrasState(models.BlockletExtra, config);
+  const cacheState = new CacheState(models.Cache, config);
+  const auditLogState = new AuditLogState(models.AuditLog, config);
+  const jobState = new JobState(models.Job, config);
+  const backupState = new BackupState(models.Backup, config);
 
   return {
     node: nodeState,
@@ -36,13 +46,13 @@ const init = (dataDirs, config) => {
     accessKey: accessKeyState,
     webhook: webhookState,
     migration: migrationState,
-    challenge: challengeState,
     session: sessionState,
     blockletExtras: extrasState,
     cache: cacheState,
     auditLog: auditLogState,
+    job: jobState,
     backup: backupState,
   };
 };
 
-module.exports = stateFactory(init);
+module.exports = createStateFactory(init, models);

package/lib/states/job.js

@@ -0,0 +1,8 @@
+const BaseState = require('./base');
+
+/**
+ * @extends BaseState<import('@abtnode/models').JobState>
+ */
+class Job extends BaseState {}
+
+module.exports = Job;

package/lib/states/migration.js

@@ -3,11 +3,10 @@ const logger = require('@abtnode/logger')('@abtnode/core:states:migration');
 
 const BaseState = require('./base');
 
+/**
+ * @extends BaseState<import('@abtnode/models').MigrationState>
+ */
 class MigrationState extends BaseState {
-  constructor(baseDir, config = {}) {
-    super(baseDir, { filename: 'migration.db', ...config });
-  }
-
   // eslint-disable-next-line no-unused-vars
   async isExecuted({ script, version }, context) {
     try {