@abtnode/db 1.8.14 → 1.8.17

package/lib/base.d.ts

@@ -0,0 +1,2 @@
+import { DataStore as BaseDataStore } from '@nedb/core';
+export const DataStore: typeof BaseDataStore;

package/lib/base.js

@@ -0,0 +1,12 @@
+const { DataStore } = require('@nedb/core');
+const { createDataStore } = require('@nedb/multi');
+
+const selectDataStore = () => {
+  if (process.env.NODE_ENV === 'test' || !process.env.NEDB_MULTI_PORT) {
+    return DataStore;
+  }
+
+  return createDataStore(Number(process.env.NEDB_MULTI_PORT));
+};
+
+module.exports.DataStore = selectDataStore();

package/lib/db.js

@@ -1,70 +1,40 @@
 const fs = require('fs');
+const EventEmitter = require('events');
 const path = require('path');
-const util = require('util');
 const cloneDeep = require('lodash.clonedeep');
-const { EventEmitter } = require('events');
+
 const packageName = require('../package.json').name;
+const { DataStore } = require('./base');
 
-const DataStore =
-  process.env.NODE_ENV === 'test' ? require('@nedb/core') : require('@nedb/multi')(Number(process.env.NEDB_MULTI_PORT));
 // eslint-disable-next-line import/order
 const logger = require('@abtnode/logger')(packageName);
 
-class DB extends EventEmitter {
-  constructor(baseDir, options) {
-    super();
-
-    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,
-    });
+class DB extends DataStore {
+  constructor(baseDir, config) {
+    const dbOptions = config.db || {};
+    const filename = path.join(baseDir, config.filename);
+
+    super({ filename, timestampData: true, ...dbOptions });
 
-    logger.info('initialized', { filename: this.filename });
+    this.filename = filename;
+    this.config = Object.freeze(cloneDeep(config));
+
+    this._patchEvents();
 
     this.ready = false;
     this.readyCallbacks = [];
-    this.db.loadDatabase((err) => {
+    this.loadDatabase((err) => {
       if (err) {
         logger.error(`failed to load disk database ${this.filename}`, { error: err });
         console.error(err);
       } else {
+        logger.info('loaded', { filename: this.filename });
         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) {
@@ -80,10 +50,9 @@ class DB extends EventEmitter {
     const pageSize = Math.min(100, size);
 
     return new Promise((resolve, reject) => {
-      this.db
-        .find(conditions)
+      this.cursor(conditions)
         .sort(sort)
-        .exec((err, docs) => {
+        .exec((err, docs = []) => {
           if (err) {
             return reject(err);
           }
@@ -112,7 +81,7 @@ class DB extends EventEmitter {
   }
 
   async updateById(id, updates, options = {}) {
-    const [, doc] = await this.asyncDB.update({ _id: id }, updates, {
+    const [, doc] = await super.update({ _id: id }, updates, {
       multi: false,
       upsert: false,
       returnUpdatedDocs: true,
@@ -122,73 +91,43 @@ class DB extends EventEmitter {
     return doc;
   }
 
-  update(...args) {
-    if (args.length === 0) {
-      throw new Error('param is required by update method');
+  update(query, updates, options = {}) {
+    if (arguments.length === 0) {
+      throw new Error('query and update param are required to update database record');
     }
 
-    if (typeof args[0] === 'string') {
-      return this.updateById(...args);
+    if (typeof query === 'string') {
+      return this.updateById(query, updates, options);
     }
 
-    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);
-      });
-    });
+    return super.update(query, updates, { returnUpdatedDocs: true, ...options });
   }
 
   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);
-  }
-
   compactDatafile() {
-    this.db.persistence.compactDatafile((err) => {
+    this.persistence.compactDatafile((err) => {
       if (err) {
         console.error(`failed to compact datafile: ${this.filename}`, err);
       }
     });
   }
+
+  // In case we are using the concurrent version
+  _patchEvents() {
+    if (typeof this.emit === 'function') {
+      return;
+    }
+
+    const events = new EventEmitter();
+
+    this.on = events.on.bind(events);
+    this.once = events.once.bind(events);
+    this.off = events.off.bind(events);
+    this.emit = events.emit.bind(events);
+  }
 }
 
 /**

package/lib/factory.d.ts

@@ -0,0 +1,8 @@
+import { AnyObject, DataStore } from '@nedb/core';
+
+declare function Factory(initializer: Function): {
+  init(...args: any[]): void;
+  [key: string]: DataStore<AnyObject>;
+};
+
+export = Factory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abtnode/db",
-  "version": "1.8.14",
+  "version": "1.8.17",
   "description": "@nedb/core wrapper",
   "author": "polunzh <polunzh@gmail.com>",
   "homepage": "https://github.com/ArcBlock/blocklet-server#readme",
@@ -29,13 +29,13 @@
     "url": "https://github.com/ArcBlock/blocklet-server/issues"
   },
   "dependencies": {
-    "@abtnode/logger": "1.8.14",
-    "@nedb/core": "^1.3.4",
-    "@nedb/multi": "^1.3.4",
+    "@abtnode/logger": "1.8.17",
+    "@nedb/core": "^2.0.3",
+    "@nedb/multi": "^2.0.3",
     "lodash.clonedeep": "^4.5.0"
   },
   "devDependencies": {
     "jest": "^27.5.1"
   },
-  "gitHead": "4b0cee41fd03d09301e2c35af46dd9e513473ef8"
+  "gitHead": "aa1854b3b71a6250182bfcad794235099f38a514"
 }