@paralect/hive 0.0.1

package/starter/src/lib/node-mongo/CHANGELOG.md

@@ -0,0 +1,98 @@
+## v2.1.0 (2020-10-15)
+
+### Features
+
+#### Manager
+
+[createService](API.md#createservice)
+
+- Add [emitter](API.md#createservice) option.
+
+## v2.0.0 (2020-09-29)
+
+- Update dependencies.
+
+### Breaking Changes
+
+#### [Manager](API.md#manager)
+
+[createQueryService](API.md#createqueryservice)
+
+- Rename `validateSchema` option to `validate`.
+- Change `addCreatedOnField` default to `true`.
+- Change `addUpdatedOnField` default to `true`.
+
+[createService](API.md#createservice)
+
+- Rename `validateSchema` option to `validate`.
+- Change `addCreatedOnField` default to `true`.
+- Change `addUpdatedOnField` default to `true`.
+
+#### [Query Service](API.md#query-service)
+
+- Remove `generateId` method.
+- Remove `expectDocument` method.
+
+#### [Service](API.md#service)
+
+- Remove `update` method. Use [updateOne](API.md#updateone) or [updateMany](API.md#updatemany).
+- Remove `ensureIndex`. Use [atomic.createIndex](API.md#atomiccreateindex).
+- Remove `createOrUpdate`. Use [create](API.md#create) or [updateOne](API.md#updateone) or [updateMany](API.md#updatemany).
+- Remove `findOneAndUpdate`. Use [findOne](API.md#findone) and [updateOne](API.md#updateone).
+
+### Features
+
+#### Manager
+
+[createQueryService](API.md#createqueryservice)
+
+- Add `useStringId` option.
+
+[createService](API.md#createservice)
+
+- Add `useStringId` option.
+
+#### [Query Service](API.md#query-service)
+
+- Add more monk's methods. [See full list](API.md#query-service)
+
+#### [Service](API.md#service)
+
+- Add [generateId](API.md#generateid) method.
+- Add [updateOne](API.md#updateone) method.
+- Add [updateMany](API.md#updatemany) method.
+- Add [performTransaction](API.md#performtransaction) method.
+- Add more monk's methods in `atomic` namespace. [See full list](API.md#service)
+
+## v1.1.0 (2019-06-25)
+
+- Update dependencies.
+- Fix required version of the Node.js.
+
+### Breaking Changes
+
+- Now `update` function will work via [set](https://docs.mongodb.com/manual/reference/operator/update/set/) operator. It means the new doc will be the result of merge of the old doc and the provided one.
+
+## v1.0.0 (2018-05-23)
+
+- Update dependencies.
+- Add tests.
+- Fix required version of the Node.js.
+
+### Breaking Changes
+
+- Now, by default, we do not add the fields `createdOn` and` updatedOn` automatically to the model. If you want to save the current behavior, add the appropriate `addCreatedOnField` and` addUpdatedOnField` options to the service definitions.
+
+## v0.3.1 (2017-12-16)
+
+- Stop using deprecated method `ensureIndex` of the `monk`.
+
+## v0.3.0 (2017-10-24)
+
+- Add ability to create custom methods for service and query service.
+- Add tests.
+
+## v0.2.0 (2017-10-12)
+
+- Add support of the [joi](https://github.com/hapijs/joi) for validating data schema.
+- Add tests for validating of the schema.

package/starter/src/lib/node-mongo/README.md

@@ -0,0 +1,97 @@
+# Node Mongo
+
+[![npm version](https://badge.fury.io/js/%40paralect%2Fnode-mongo.svg)](https://badge.fury.io/js/%40paralect%2Fnode-mongo)
+
+Node Mongo is reactive extension to MongoDB API. It provides few usability improvements to the [monk](https://github.com/Automattic/monk) API.
+
+## Features
+
+- ️️**Reactive**. Fires events as document stored, updated or deleted from database
+- **Paging**. Implements high level paging API
+- **Schema validation**. Validates your data before save
+
+## Installation
+
+```
+npm i @paralect/node-mongo
+```
+
+## Documentation
+
+[API Reference](API.md).
+
+## Usage
+
+### Connect to MongoDB
+
+```javascript
+const connectionString = "mongodb://localhost:27017/home-db";
+const db = require("@paralect/node-mongo").connect(connectionString);
+```
+
+### CRUD Operations
+
+```javascript
+// create a service to work with specific database collection
+const userService = db.createService("users");
+
+// create documents
+const users = await userService.create([{ name: "Alex" }, { name: "Bob" }]);
+
+// find one document
+const user = await userService.findOne({ name: "Bob" });
+
+// find many documents with pagination
+const { results, pagesCount, count } = await userService.find(
+  { name: "Bob" },
+  { page: 1, perPage: 30 }
+);
+
+// update document
+const updatedUser = await userService.updateOne({ _id: "1" }, (doc) => ({
+  ...doc,
+  name: "Alex",
+}));
+
+// remove document
+const removedUser = await userService.remove({ _id: "1" });
+```
+
+### Event handlers
+
+```js
+const userService = db.createService("users");
+
+userService.on("created", ({ doc }) => {});
+
+userService.on("updated", ({ doc, prevDoc }) => {});
+
+userService.onPropertiesUpdated(["email"], ({ doc, prevDoc }) => {});
+
+userService.on("removed", ({ doc }) => {});
+```
+
+### Schema validation
+
+```javascript
+const Joi = require("Joi");
+
+const userSchema = Joi.object({
+  _id: Joi.string(),
+  createdOn: Joi.date(),
+  name: Joi.string(),
+  status: Joi.string().valid("active", "inactive"),
+});
+
+function validate(obj) {
+  return userSchema.validate(obj);
+}
+
+const userService = db.createService("users", { validate });
+```
+
+## Change Log
+
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+Every release is documented on the Github [Releases](https://github.com/paralect/node-mongo/releases) page.

package/starter/src/lib/node-mongo/package.json

@@ -0,0 +1,74 @@
+{
+  "_args": [
+    [
+      "@paralect/node-mongo@2.1.1",
+      "/Users/igorkrasnik/Documents/work/trojanflix-api"
+    ]
+  ],
+  "_from": "@paralect/node-mongo@2.1.1",
+  "_id": "@paralect/node-mongo@2.1.1",
+  "_inBundle": false,
+  "_integrity": "sha512-IneYD4qTa2P0St3m3Zlw/nRXejTsrsepkmEy7Qw0KYjEQeoekr6gxC6edOPouupkQA0qBOUl4zQSdkaEIUn36w==",
+  "_location": "/@paralect/node-mongo",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "@paralect/node-mongo@2.1.1",
+    "name": "@paralect/node-mongo",
+    "escapedName": "@paralect%2fnode-mongo",
+    "scope": "@paralect",
+    "rawSpec": "2.1.1",
+    "saveSpec": null,
+    "fetchSpec": "2.1.1"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/@paralect/node-mongo/-/node-mongo-2.1.1.tgz",
+  "_spec": "2.1.1",
+  "_where": "/Users/igorkrasnik/Documents/work/trojanflix-api",
+  "author": {
+    "name": "Paralect"
+  },
+  "bugs": {
+    "url": "https://github.com/paralect/node-mongo/issues"
+  },
+  "dependencies": {
+    "lodash": "4.17.20",
+    "monk": "7.3.2"
+  },
+  "description": "MongoDB wrapper for Node.JS 12",
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "chai-spies": "^1.0.0",
+    "eslint": "^7.10.0",
+    "eslint-config-airbnb-base": "^14.2.0",
+    "eslint-plugin-import": "^2.22.1",
+    "mocha": "^8.1.3",
+    "npm-run-all": "^4.1.5"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "homepage": "https://github.com/paralect/node-mongo#readme",
+  "keywords": [
+    "mongo",
+    "monk",
+    "paralect"
+  ],
+  "license": "MIT",
+  "main": "src/index.js",
+  "name": "@paralect/node-mongo",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paralect/node-mongo.git"
+  },
+  "scripts": {
+    "test": "run-s test:*",
+    "test:eslint": "eslint ./",
+    "test:mocha": "NODE_ENV=test mocha --exit --recursive -c -R spec src/index.test.js"
+  },
+  "version": "2.1.1"
+}

package/starter/src/lib/node-mongo/src/index.js

@@ -0,0 +1,67 @@
+const monk = require("monk");
+const _ = require("lodash");
+
+const MongoService = require("./mongo-service");
+const MongoQueryService = require("./mongo-query-service");
+
+const logger = global.logger || console;
+
+const connect = (connectionString, settings) => {
+  const connectionSettings = _.defaults({}, settings, {
+    connectTimeoutMS: 20000,
+  });
+  const db = monk(connectionString, connectionSettings);
+
+  db.on("error-opening", (err) => {
+    logger.error(err, "Failed to connect to the mongodb on start");
+    throw err;
+  });
+
+  db.on("open", () => {
+    logger.info(`Connected to mongodb: ${connectionString}`);
+  });
+
+  db.on("close", (err) => {
+    if (err) {
+      logger.error(err, `Lost connection with mongodb: ${connectionString}`);
+    } else {
+      logger.warn(`Closed connection with mongodb: ${connectionString}`);
+    }
+  });
+
+  db.on("connected", (err) => {
+    if (err) {
+      logger.error(err);
+    } else {
+      logger.info(`Connected to mongodb: ${connectionString}`);
+    }
+  });
+
+  db.createService = (collectionName, options = {}) => {
+    const collection = db.get(collectionName, { castIds: false });
+
+    return new MongoService(collection, options);
+  };
+
+  db.setServiceMethod = (name, method) => {
+    MongoService.prototype[name] = function customMethod(...args) {
+      return method.apply(this, [this, ...args]);
+    };
+  };
+
+  db.createQueryService = (collectionName, options = {}) => {
+    const collection = db.get(collectionName, { castIds: false });
+
+    return new MongoQueryService(collection, options);
+  };
+
+  db.setQueryServiceMethod = (name, method) => {
+    MongoQueryService.prototype[name] = function customMethod(...args) {
+      return method.apply(this, [this, ...args]);
+    };
+  };
+
+  return db;
+};
+
+module.exports.connect = connect;

package/starter/src/lib/node-mongo/src/mongo-query-service.js

@@ -0,0 +1,72 @@
+const _ = require("lodash");
+
+const MongoServiceError = require("./mongo-service-error");
+
+class MongoQueryService {
+  constructor(collection, options = {}) {
+    this._collection = collection;
+    this._options = options;
+
+    this.name = collection.name;
+
+    this.aggregate = collection.aggregate;
+    this.count = collection.count;
+    this.distinct = collection.distinct;
+    this.geoHaystackSearch = collection.geoHaystackSearch;
+    this.indexes = collection.indexes;
+    this.mapReduce = collection.mapReduce;
+    this.stats = collection.stats;
+  }
+
+  async find(query = {}, opt = { perPage: 100, page: 0 }) {
+    const options = _.cloneDeep(opt);
+    const { page, perPage } = options;
+    const hasPaging = page > 0;
+    if (hasPaging) {
+      options.skip = (page - 1) * perPage;
+      options.limit = perPage;
+    }
+    delete options.perPage;
+    delete options.page;
+
+    const results = await this._collection.find(query, options);
+    if (!hasPaging) {
+      return {
+        results,
+      };
+    }
+
+    const countOptions = {};
+    if (options.session) countOptions.session = options.session;
+    const count = await this._collection.count(query, countOptions);
+    const pagesCount = Math.ceil(count / perPage) || 1;
+
+    return {
+      pagesCount,
+      results,
+      count,
+    };
+  }
+
+  async findOne(query = {}, options = {}) {
+    const { results } = await this.find(query, { limit: 2, ...options });
+
+    if (results.length > 1) {
+      throw new MongoServiceError(
+        MongoServiceError.MORE_THAN_ONE,
+        `findOne: More than one document return for query ${JSON.stringify(
+          query
+        )}`
+      );
+    }
+
+    return results[0] || null;
+  }
+
+  async exists(query, options = {}) {
+    const count = await this.count(query, { limit: 1, ...options });
+    return count > 0;
+  }
+}
+
+module.exports = MongoQueryService;

package/starter/src/lib/node-mongo/src/mongo-service-error.js

@@ -0,0 +1,15 @@
+class MongoServiceError extends Error {
+  constructor(code, message, error) {
+    super(message);
+    this.name = "MongoServiceError";
+    this.code = code;
+    this.error = error;
+  }
+}
+
+MongoServiceError.NOT_FOUND = "NOT_FOUND";
+MongoServiceError.MORE_THAN_ONE = "MORE_THAN_ONE";
+MongoServiceError.INVALID_SCHEMA = "INVALID_SCHEMA";
+MongoServiceError.INVALID_ARGUMENT = "INVALID_ARGUMENT";
+
+module.exports = MongoServiceError;

package/starter/src/lib/node-mongo/src/mongo-service.js

@@ -0,0 +1,279 @@
+const monk = require("monk");
+const { EventEmitter } = require("events");
+const _ = require("lodash");
+
+const MongoQueryService = require("./mongo-query-service");
+const MongoServiceError = require("./mongo-service-error");
+
+const defaultOptions = {
+  addCreatedOnField: true,
+  addUpdatedOnField: true,
+  useStringId: true,
+  validate: undefined,
+  emitter: undefined,
+
+  onBeforeCreated: ({ docs }) => docs,
+};
+
+class MongoService extends MongoQueryService {
+  constructor(collection, options = {}) {
+    super(collection, options);
+
+    _.defaults(this._options, defaultOptions);
+
+    this._bus = this._options.emitter || new EventEmitter();
+
+    this.generateId = () => monk.id().toHexString();
+
+    this.atomic = {
+      bulkWrite: collection.bulkWrite,
+      createIndex: collection.createIndex,
+      drop: collection.drop,
+      dropIndex: collection.dropIndex,
+      dropIndexes: collection.dropIndexes,
+      findOneAndDelete: collection.findOneAndDelete,
+      findOneAndUpdate: collection.findOneAndUpdate,
+      insert: collection.insert,
+      remove: collection.remove,
+      update: collection.update,
+    };
+
+    collection.manager
+      .executeWhenOpened()
+      .then(async () => {
+        await collection.manager._db.command({ create: collection.name });
+      })
+      .catch((error) => {
+        // a collection already exists
+        if (error.code !== 48) {
+          throw error;
+        }
+      });
+  }
+
+  static _deepCompare(data, initialData, properties) {
+    let changed = false;
+
+    if (Array.isArray(properties)) {
+      changed =
+        _.find(properties, (prop) => {
+          const value = _.get(data, prop);
+          const initialValue = _.get(initialData, prop);
+
+          return !_.isEqual(value, initialValue);
+        }) !== undefined;
+    } else {
+      Object.keys(properties).forEach((prop) => {
+        if (changed) return;
+
+        const value = _.get(data, prop);
+        const initialValue = _.get(initialData, prop);
+
+        if (
+          _.isEqual(value, properties[prop]) &&
+          !_.isEqual(initialValue, properties[prop])
+        ) {
+          changed = true;
+        }
+      });
+    }
+
+    return changed;
+  }
+
+  async _validate(entity) {
+    if (this._options.validate) {
+      const { value, error } = await this._options.validate(entity);
+
+      if (error) {
+        console.log("Schema Error", error);
+
+        throw new MongoServiceError(
+          MongoServiceError.INVALID_SCHEMA,
+          `Document schema is invalid: ${JSON.stringify(error, null, 2)}`,
+          error
+        );
+      }
+
+      return value;
+    }
+
+    return entity;
+  }
+
+  emit(eventName, event) {
+    return this._bus.emit(eventName, event);
+  }
+
+  once(eventName, handler) {
+    return this._bus.once(eventName, handler);
+  }
+
+  on(eventName, handler) {
+    return this._bus.on(eventName, handler);
+  }
+
+  onPropertiesUpdated(properties, handler) {
+    return this.on("updated", (event) => {
+      const isChanged = MongoService._deepCompare(
+        event.doc,
+        event.prevDoc,
+        properties
+      );
+      if (isChanged) handler(event);
+    });
+  }
+
+  async create(objs, options = {}) {
+    const entities = _.isArray(objs) ? objs : [objs];
+
+    let created = await Promise.all(
+      entities.map(async (doc) => {
+        const entity = _.cloneDeep(doc);
+
+        if (this._options.useStringId && !entity._id)
+          entity._id = this.generateId();
+        if (this._options.addCreatedOnField && !entity.createdOn) {
+          entity.createdOn = new Date().toISOString();
+        }
+        const validated = await this._validate(entity);
+
+        return validated;
+      })
+    );
+
+    created = await this._options.onBeforeCreated({ docs: created });
+
+    await this._collection.insert(created, options);
+
+    created.forEach((doc) => {
+      this._bus.emit("created", {
+        doc,
+      });
+    });
+
+    return created.length > 1 ? created : created[0];
+  }
+
+  async updateOne(query, updateFn, options = {}) {
+    if (!_.isFunction(updateFn)) {
+      throw new MongoServiceError(
+        MongoServiceError.INVALID_ARGUMENT,
+        `updateOne: second argument is invalid. Expected a function but got ${typeof updateFn}`
+      );
+    }
+
+    const findOptions = {};
+    if (options.session) findOptions.session = options.session;
+    const doc = await this.findOne(query, findOptions);
+    if (!doc) {
+      throw new MongoServiceError(
+        MongoServiceError.NOT_FOUND,
+        `updateOne: document not found. Query: ${JSON.stringify(query)}`
+      );
+    }
+
+    let entity = _.cloneDeep(doc);
+
+    if (this._options.addUpdatedOnField)
+      entity.updatedOn = new Date().toISOString();
+    entity = await updateFn(entity);
+    const updated = await this._validate(entity);
+
+    await this._collection.update(
+      { ...query, _id: doc._id },
+      { $set: updated },
+      options
+    );
+
+    this._bus.emit("updated", {
+      doc: updated,
+      prevDoc: doc,
+    });
+
+    return updated;
+  }
+
+  async updateMany(query, updateFn, options = {}) {
+    if (!_.isFunction(updateFn)) {
+      throw new MongoServiceError(
+        MongoServiceError.INVALID_ARGUMENT,
+        `updateMany: second argument is invalid. Expected a function but got ${typeof updateFn}`
+      );
+    }
+
+    const findOptions = {};
+    if (options.session) findOptions.session = options.session;
+    const { results: docs } = await this.find(query, findOptions);
+    if (docs.length === 0) return [];
+
+    const updated = await Promise.all(
+      docs.map(async (doc) => {
+        let entity = _.cloneDeep(doc);
+
+        if (this._options.addUpdatedOnField)
+          entity.updatedOn = new Date().toISOString();
+        entity = await updateFn(entity);
+        const validated = await this._validate(entity);
+
+        return validated;
+      })
+    );
+
+    await Promise.all(
+      updated.map((doc) =>
+        this._collection.update(
+          { ...query, _id: doc._id },
+          { $set: doc },
+          options
+        )
+      )
+    );
+
+    updated.forEach((doc, index) => {
+      this._bus.emit("updated", {
+        doc,
+        prevDoc: docs[index],
+      });
+    });
+
+    return updated;
+  }
+
+  async remove(query, options = {}) {
+    const findOptions = {};
+    if (options.session) findOptions.session = options.session;
+    const removed = await this.find(query, findOptions);
+    await this._collection.remove(query, options);
+
+    removed.results.forEach((doc) => {
+      this._bus.emit("removed", {
+        doc,
+      });
+    });
+
+    return removed;
+  }
+
+  async performTransaction(transactionFn, options = {}) {
+    if (!_.isFunction(transactionFn)) {
+      throw new MongoServiceError(
+        MongoServiceError.INVALID_ARGUMENT,
+        `performTransaction: first argument is invalid. Expected a function but got ${typeof transactionFn}`
+      );
+    }
+
+    await this._collection.manager.executeWhenOpened();
+
+    const session = this._collection.manager._client.startSession(options);
+
+    try {
+      await session.withTransaction(transactionFn);
+    } catch (error) {
+      session.endSession();
+      throw error;
+    }
+  }
+}
+
+module.exports = MongoService;