@abtnode/db 1.6.7

package/README.md

@@ -0,0 +1,11 @@
+# `@abtnode/db`
+
+> TODO: description
+
+## Usage
+
+```
+const db = require('@abtnode/db');
+
+// TODO: DEMONSTRATE API
+```

package/lib/db.js

@@ -0,0 +1,224 @@
+const fs = require('fs');
+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 =
+  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,
+    });
+
+    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);
+    }
+  }
+
+  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);
+  }
+
+  compactDatafile() {
+    this.db.persistence.compactDatafile((err) => {
+      if (err) {
+        console.error(`failed to compact datafile: ${this.filename}`, err);
+      }
+    });
+  }
+}
+
+/**
+ * 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;
+};
+
+DB.renameIdFiledName = renameIdFiledName;
+
+module.exports = DB;

package/lib/factory.js

@@ -0,0 +1,20 @@
+module.exports = (initializer) => {
+  const states = {};
+
+  return new Proxy(
+    {},
+    {
+      get(target, prop) {
+        if (prop === 'init') {
+          return (...args) => Object.assign(states, initializer(...args));
+        }
+
+        if (states[prop]) {
+          return states[prop];
+        }
+
+        throw new Error(`State ${String(prop)} may not be initialized`);
+      },
+    }
+  );
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@abtnode/db",
+  "version": "1.6.7",
+  "description": "@nedb/core wrapper",
+  "author": "polunzh <polunzh@gmail.com>",
+  "homepage": "https://github.com/ArcBlock/blocklet-server#readme",
+  "license": "MIT",
+  "main": "lib/db.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "files": [
+    "lib"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ArcBlock/blocklet-server.git"
+  },
+  "scripts": {
+    "lint": "eslint tests lib",
+    "lint:fix": "eslint --fix tests lib",
+    "test": "node tools/jest.js",
+    "coverage": "npm run test -- --coverage"
+  },
+  "bugs": {
+    "url": "https://github.com/ArcBlock/blocklet-server/issues"
+  },
+  "dependencies": {
+    "@abtnode/logger": "1.6.7",
+    "@nedb/core": "^1.2.2",
+    "@nedb/multi": "^1.2.2",
+    "lodash.clonedeep": "^4.5.0"
+  },
+  "devDependencies": {
+    "jest": "^27.4.5"
+  },
+  "gitHead": "d681c03a398e3c7d4dbc878db93b2ab778dded81"
+}