@abtnode/core 1.15.17 → 1.16.0-beta-8ee536d7

package/lib/states/base.js

@@ -1,226 +1,17 @@
-const fs = require('fs');
-const path = require('path');
-const util = require('util');
-const { EventEmitter } = require('events');
-const cloneDeep = require('lodash/cloneDeep');
-const DataStore =
-  process.env.NODE_ENV === 'test' ? require('@nedb/core') : require('@nedb/multi')(Number(process.env.NEDB_MULTI_PORT));
+const DB = require('@abtnode/db');
 const logger = require('@abtnode/logger')('@abtnode/core:states');
 
 const { isCLI } = require('../util');
 
-class BaseState extends EventEmitter {
-  constructor(baseDir, options) {
-    super();
+class BaseState extends DB {
+  constructor(baseDir, config) {
+    super(baseDir, config);
 
     // HACK: do not emit any events from CLI
     if (isCLI() && process.env.NODE_ENV !== 'test') {
       this.emit = (name) => logger.debug('stopped state db event in CLI', name);
     }
-
-    const dbOptions = options.db || {};
-    this.filename = path.join(baseDir, options.filename);
-    this.options = Object.freeze(cloneDeep(options));
-    this.db = new DataStore({
-      filename: this.filename,
-      timestampData: true,
-      ...dbOptions,
-    });
-
-    logger.info('initialized', { filename: this.filename });
-
-    this.ready = false;
-    this.readyCallbacks = [];
-    this.db.loadDatabase((err) => {
-      if (err) {
-        logger.error(`failed to load disk database ${this.filename}`, { error: err });
-        console.error(err);
-      } else {
-        this.ready = true;
-        if (this.readyCallbacks.length) {
-          this.readyCallbacks.forEach((x) => x());
-        }
-      }
-    });
-
-    this.asyncDB = new Proxy(this.db, {
-      get(target, property) {
-        if (typeof target[property] === 'function') {
-          return util
-            .promisify((...args) => {
-              const cb = args[args.length - 1];
-              const rest = args.slice(0, args.length - 1);
-
-              target[property](...rest, (err, ...result) => {
-                if (err) {
-                  return cb(err);
-                }
-
-                if (result.length === 1) {
-                  return cb(null, result[0]);
-                }
-
-                return cb(null, result);
-              });
-            })
-            .bind(target);
-        }
-
-        return target[property];
-      },
-    });
-  }
-
-  onReady(cb) {
-    if (this.ready) {
-      cb();
-    } else {
-      this.readyCallbacks.push(cb);
-    }
-  }
-
-  createNotification(payload) {
-    if (this.notification && typeof this.notification.create === 'function') {
-      this.notification.create(payload);
-    }
-  }
-
-  paginate(conditions, sort, paging) {
-    const { pageSize: size = 20, page = 1 } = paging || {};
-    const pageSize = Math.min(100, size);
-
-    return new Promise((resolve, reject) => {
-      this.db
-        .find(conditions)
-        .sort(sort)
-        .exec((err, docs) => {
-          if (err) {
-            return reject(err);
-          }
-
-          const pageCount = Math.ceil(docs.length / pageSize);
-          const total = docs.length;
-          const skip = (page - 1) * pageSize;
-          const list = docs.slice(skip, skip + pageSize);
-
-          list.forEach((doc) => {
-            // eslint-disable-next-line no-underscore-dangle
-            doc.id = doc._id;
-          });
-
-          return resolve({
-            list,
-            paging: {
-              total,
-              pageSize,
-              pageCount,
-              page,
-            },
-          });
-        });
-    });
-  }
-
-  async updateById(id, updates, options = {}) {
-    const [, doc] = await this.asyncDB.update({ _id: id }, updates, {
-      multi: false,
-      upsert: false,
-      returnUpdatedDocs: true,
-      ...options,
-    });
-
-    return doc;
-  }
-
-  update(...args) {
-    if (args.length === 0) {
-      throw new Error('param is required by update method');
-    }
-
-    if (typeof args[0] === 'string') {
-      return this.updateById(...args);
-    }
-
-    return this.asyncDB.update(args[0], args[1], { returnUpdatedDocs: true, ...(args[2] || {}) });
-  }
-
-  count(conditions = {}) {
-    return new Promise((resolve, reject) => {
-      this.db.count(conditions, (err, num) => {
-        if (err) {
-          return reject(err);
-        }
-
-        return resolve(num);
-      });
-    });
-  }
-
-  remove(conditions = {}, options = { multi: false }) {
-    return new Promise((resolve, reject) => {
-      this.db.remove(conditions, options, (err, num) => {
-        if (err) {
-          return reject(err);
-        }
-
-        return resolve(num);
-      });
-    });
-  }
-
-  reset() {
-    fs.unlinkSync(this.filename);
-  }
-
-  find(...args) {
-    if (args.length === 0) {
-      return this.asyncDB.find({});
-    }
-
-    return this.asyncDB.find(...args);
-  }
-
-  findOne(...args) {
-    if (args.length === 0) {
-      return this.asyncDB.findOne({});
-    }
-
-    return this.asyncDB.findOne(...args);
-  }
-
-  insert(...args) {
-    return this.asyncDB.insert(...args);
   }
 }
 
-/**
- * Rename _id field name to id, this method has side effects
- * @param {object} entities
- */
-const renameIdFiledName = (entities, from = '_id', to = 'id') => {
-  /* eslint-disable  no-underscore-dangle, no-param-reassign */
-
-  if (!entities) {
-    return entities;
-  }
-
-  const mapEntity = (entity) => {
-    if (entity[from]) {
-      entity[to] = entity[from];
-      delete entity[from];
-    }
-  };
-
-  if (!Array.isArray(entities)) {
-    mapEntity(entities);
-    return entities;
-  }
-
-  entities.forEach(mapEntity);
-
-  return entities;
-};
-
-BaseState.renameIdFiledName = renameIdFiledName;
-
 module.exports = BaseState;

package/lib/states/blocklet-extras.js

@@ -2,27 +2,79 @@
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable consistent-return */
 const logger = require('@abtnode/logger')('state-blocklet-extras');
+const { EXPIRED_BLOCKLET_DATA_RETENTION_DAYS } = require('@abtnode/constant');
 const camelCase = require('lodash/camelCase');
+const get = require('lodash/get');
+const uniq = require('lodash/uniq');
+const dayjs = require('dayjs');
 
 const BaseState = require('./base');
 
-const { mergeConfigs } = require('../blocklet/extras');
+const { mergeConfigs, parseConfigs, encryptConfigs } = require('../blocklet/extras');
+const { validateAddMeta, validateExpiredInfo } = require('../validators/blocklet-extra');
+
+const noop = (k) => (v) => v[k];
+
+// type Settings = {
+//   whoCanAccess: string;
+//   initialized: boolean;
+//   owner: {
+//     did: string;
+//     pk: string;
+//   };
+//   storeList: Array<getStoreMeta & {
+//     protected: boolean,
+//     url: string,
+//   }>; // 在 blocklet dashboard 添加组件时的商店列表
+//   navigations: any;
+//   trustedPassports: any;
+//   enablePassportIssuance: boolean;
+//   children: Array<any>; // deleted children
+//   publicToStore: boolean;
+//   navigation: Array[{
+//     title: string;
+//     child: DID | Name;
+//   }]; // deprecated
+// };
+
+// type Configs = {
+//   [componentDid: string]: Config;
+// };
+
+// type Children = Array<{
+//   did: string, // application index
+//   configs: Configs,
+//   children: Children
+// }>;
+
+// type ExtraState = {
+//   did: string; // application index
+//   meta: {
+//     did: string; // application index
+//     name: string; // application index
+//   };
+//   controller: BlockletController;
+//   settings: Settings;
+//   configs: Configs;
+//   children: Children
+// };
 
 class BlockletExtrasState extends BaseState {
-  constructor(baseDir, options = {}) {
-    super(baseDir, { filename: 'blocklet_extras.db', ...options });
+  constructor(baseDir, config = {}) {
+    super(baseDir, { filename: 'blocklet_extras.db', ...config });
 
     this.extras = [
       // environment
       {
         name: 'configs',
         beforeSet: mergeConfigs,
+        afterGet: parseConfigs,
       },
 
       // setting
       {
         name: 'settings',
-        beforeSet: (old, cur) => {
+        beforeSet: ({ old, cur }) => {
           const merged = { ...old, ...cur };
           Object.keys(merged).forEach((key) => {
             if (merged[key] === undefined || merged[key] === null) {
@@ -33,25 +85,29 @@ class BlockletExtrasState extends BaseState {
         },
       },
     ];
+
+    this.childExtras = this.extras.filter((x) => ['configs'].includes(x.name));
+
     this.generateExtraFns();
   }
 
+  delete(did) {
+    return this.remove({ did });
+  }
+
   generateExtraFns() {
-    const methods = ['get', 'set', 'del'];
+    const methods = ['get', 'set', 'del', 'list'];
     methods.forEach((method) => {
       this.extras.forEach((extra) => {
         const fn = camelCase(`${method} ${extra.name}`); // getConfigs, getRules
-        this[fn] = this.generateExtraFn(method, extra);
-
-        const childFn = camelCase(`${method} child ${extra.name}`); // getChildConfigs, getChildRules
-        this[childFn] = this.generateExtraChildFn(method, extra);
+        this[fn] = this.generateFn(method, extra);
       });
     });
   }
 
-  // generate extra functions
+  // generate functions
 
-  generateExtraFn(method, extra) {
+  generateFn(method, extra) {
     if (method === 'get') {
       return this.generateGetFn(extra);
     }
@@ -63,176 +119,177 @@ class BlockletExtrasState extends BaseState {
     if (method === 'del') {
       return this.generateDelFn(extra);
     }
+
+    if (method === 'list') {
+      return this.generateListFn(extra);
+    }
   }
 
   generateGetFn(extra) {
-    return async (did) => {
-      const { name } = extra;
-      const item = await this.asyncDB.findOne({ did });
-      return item ? item[name] : item;
+    return async (dids, path, defaultValue) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = uniq([].concat(dids));
+      const [rootDid, ...childDids] = dids;
+      const { dek } = this.config;
+      const { name, afterGet = noop('data') } = extra;
+
+      let item = await this.findOne({ did: rootDid });
+      while (item && childDids.length) {
+        const did = childDids.shift();
+        item = (item.children || []).find((x) => x.did === did);
+      }
+
+      const data = afterGet({ data: item ? item[name] : item, did: rootDid, dek });
+      if (!path) {
+        return data;
+      }
+      return get(data, path, defaultValue);
     };
   }
 
   generateSetFn(extra) {
-    return async (did, data) => {
-      const { name, beforeSet } = extra;
-      const hasBeforeSet = beforeSet && typeof beforeSet === 'function';
-      const item = await this.asyncDB.findOne({ did });
+    return async (dids, data) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = uniq([].concat(dids));
+      const [rootDid, ...childDids] = dids;
+      const { dek } = this.config;
+      const { name, beforeSet = noop('cur') } = extra;
+      const exist = await this.findOne({ did: rootDid });
+
+      const item = exist || { did: rootDid };
+      let component = item;
+      while (childDids.length) {
+        const did = childDids.shift();
+        component.children = component.children || [];
+        let child = component.children.find((x) => x.did === did);
+        if (!child) {
+          child = { did };
+          component.children.push(child);
+        }
+        component = child;
+      }
 
-      if (!item) {
-        const insertData = {
-          did,
-          [name]: hasBeforeSet ? beforeSet(undefined, data) : data,
-        };
-
-        const info = await this.asyncDB.insert(insertData);
-        logger.info('create info success');
-        return info[name];
+      const old = component[name];
+      const newData = beforeSet({ old, cur: data, did: rootDid, dek });
+      component[name] = newData;
+
+      if (!exist) {
+        await this.insert(item);
+        logger.info('create extra success', { name, dids });
+      } else {
+        await this.update(item._id, item);
+        logger.info('update extra success', { name, dids });
       }
 
-      const itemNameValue = item[name];
-      const updated = await this.update(item._id, {
-        $set: {
-          [name]: hasBeforeSet ? beforeSet(itemNameValue, data) : data,
-        },
-      });
-      return updated[name];
+      // re get data because should return decrypted secure value
+      const getFn = this[camelCase(`get ${extra.name}`)].bind(this);
+      return getFn(dids);
     };
   }
 
   generateDelFn(extra) {
-    return async (did) => {
+    return async (dids) => {
+      // eslint-disable-next-line no-param-reassign
+      dids = uniq([].concat(dids));
+      const [rootDid, ...childDids] = dids;
       const { name } = extra;
-      const item = await this.asyncDB.findOne({ did });
+      const item = await this.findOne({ did: rootDid });
 
       if (!item) {
-        return item;
+        return null;
       }
 
-      await this.update(item._id, { $set: { [name]: null } });
-      return item[name];
-    };
-  }
+      let component = item;
+      while (component && childDids.length) {
+        const did = childDids.shift();
+        component = (component.children || []).find((x) => x.did === did);
+      }
 
-  // generate extra child functions
+      if (!component) {
+        return null;
+      }
 
-  generateExtraChildFn(method, extra) {
-    if (method === 'get') {
-      return this.generateGetChildFn(extra);
-    }
+      const updated = component[name];
+      component[name] = null;
 
-    if (method === 'set') {
-      return this.generateSetChildFn(extra);
-    }
+      await this.update(item._id, item);
 
-    if (method === 'del') {
-      return this.generateDelChildFn(extra);
-    }
+      return updated;
+    };
   }
 
-  generateGetChildFn(extra) {
-    return async (did, childDid) => {
-      const { name } = extra;
-      const item = await this.asyncDB.findOne({ did });
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
-      return subItem ? subItem[name] : null;
+  generateListFn(extra) {
+    return async () => {
+      const { dek } = this.config;
+      const { name, afterGet = noop('data') } = extra;
+      const docs = await this.find({});
+      const list = docs
+        .filter((x) => x[name])
+        .map((x) => ({
+          did: x.did,
+          [name]: afterGet({ data: x[name], did: x.did, dek }),
+        }));
+      return list;
     };
   }
 
-  generateSetChildFn(extra) {
-    return async (did, childDid, data) => {
-      const { name, beforeSet } = extra;
-      const hasBeforeSet = beforeSet && typeof beforeSet === 'function';
-      const item = await this.asyncDB.findOne({ did });
+  async addMeta({ did, meta, controller } = {}) {
+    const entity = { did, meta };
+    if (controller) {
+      entity.controller = controller;
+    }
 
-      if (!item) {
-        const newData = hasBeforeSet ? beforeSet(undefined, data) : data;
-        const insertData = {
-          did,
-          children: [
-            {
-              did: childDid,
-              [name]: newData,
-            },
-          ],
-        };
-        await this.asyncDB.insert(insertData);
-
-        logger.info('create info success; insert child info success');
-
-        return newData;
-      }
+    await validateAddMeta(entity);
 
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
-
-      if (!subItem) {
-        const newData = hasBeforeSet ? beforeSet(undefined, data) : data;
-        await this.update(item._id, {
-          $addToSet: {
-            children: {
-              did: childDid,
-              [name]: newData,
-            },
-          },
-        });
-
-        logger.info('insert child info success');
-        return newData;
-      }
+    return super.update({ did }, { $set: entity }, { upsert: true });
+  }
 
-      const newData = hasBeforeSet ? beforeSet(subItem[name], data) : data;
+  async getMeta(did) {
+    return super.findOne({ did }, { did: 1, controller: 1, meta: 1 });
+  }
 
-      children.forEach((x) => {
-        if (x.did === childDid) {
-          x[name] = newData;
-        }
-      });
+  async updateExpireInfo({ did, expiredAt } = {}) {
+    const entity = { did, expiredAt };
+    await validateExpiredInfo(entity);
 
-      await this.update(item._id, {
-        $set: {
-          children,
-        },
-      });
+    return super.update({ did }, { $set: { expiredAt } });
+  }
 
-      return newData;
-    };
+  async getExpiredList() {
+    const now = dayjs();
+
+    return super.find({
+      'controller.nftId': { $exists: true },
+      expiredAt: { $exists: true, $lte: now.subtract(EXPIRED_BLOCKLET_DATA_RETENTION_DAYS, 'days').toISOString() },
+    });
   }
 
-  generateDelChildFn(extra) {
-    return async (did, childDid) => {
-      const { name } = extra;
-      const item = await this.asyncDB.findOne({ did });
+  encryptSecurityData({ data, _rootDid } = {}) {
+    if (!data) {
+      return data;
+    }
 
-      if (!item) {
-        return null;
-      }
+    const { dek } = this.config;
 
-      const children = (item || {}).children || [];
-      const subItem = (children || []).find((x) => x.did === childDid);
+    if (!dek) {
+      return data;
+    }
 
-      if (!subItem) {
-        return null;
-      }
+    const did = _rootDid || data.did;
 
-      let updated = null;
+    if (!did) {
+      throw new Error('data.did does not exist');
+    }
 
-      children.forEach((x) => {
-        if (x.did === childDid) {
-          updated = x[name];
-          x[name] = null;
-        }
-      });
+    encryptConfigs({ data: data.configs, did, dek });
 
-      await this.update(item._id, {
-        $set: {
-          children,
-        },
-      });
+    if (Array.isArray(data.children)) {
+      for (const child of data.children) {
+        this.encryptSecurityData({ data: child, _rootDid: did });
+      }
+    }
 
-      return updated;
-    };
+    return data;
   }
 }