@lykmapipo/mongoose-common 0.39.0 → 0.40.0

package/src/plugins/error.plugin.js

@@ -0,0 +1,183 @@
+import { filter, forEach, isEmpty, isFunction, map, nth } from 'lodash';
+import { uniq } from '@lykmapipo/common';
+import mongoose from 'mongoose-valid8';
+
+/**
+ * @function isUniqueError
+ * @name isUniqueError
+ * @description Check if the given error is a unique mongodb error.
+ * @param {object} error valid error object to test.
+ * @returns {boolean} true if and only if it is an unique error.
+ * @version 0.2.0
+ * @since 0.1.0
+ * @private
+ */
+const isUniqueError = (error) => {
+  return (
+    error &&
+    (error.name === 'BulkWriteError' ||
+      error.name === 'MongoError' ||
+      error.name === 'MongoServerError' ||
+      error.name === 'MongoBulkWriteError') &&
+    (error.code === 11000 || error.code === 11001) &&
+    !isEmpty(error.message)
+  );
+};
+
+/**
+ * @function parseErrorPaths
+ * @name parseErrorPaths
+ * @description Parse paths found in unique mongodb error.
+ * @param {object} schema valid mongoose schema.
+ * @param {Error} error valid mongodb error.
+ * @returns {string[]} found paths in error.
+ * @version 0.19.0
+ * @since 0.1.0
+ * @private
+ */
+const parseErrorPaths = (schema, error) => {
+  // back off if no error message
+  if (!error.message) {
+    return [];
+  }
+
+  // obtain paths from error message
+  let paths = nth(error.message.match(/index: (.+?) dup key:/), 1) || '';
+  paths = paths.split('$').pop();
+
+  // handle compound unique paths index
+  paths = [].concat(paths.split('_'));
+
+  // in case for id ensure _id too and compact paths
+  paths = uniq([
+    ...paths,
+    ...map(paths, (pathName) => (pathName === 'id' ? '_id' : pathName)),
+  ]);
+
+  // ensure paths are within schema
+  paths = filter(paths, (pathName) => !isEmpty(schema.path(pathName)));
+
+  // return found paths
+  return paths;
+};
+
+/**
+ * @function parseErrorValues
+ * @name parseErrorValues
+ * @description Parse paths value found in unique mongodb error.
+ * @param {string[]} paths paths found in unique mongodb error.
+ * @param {Error} error valid mongodb error.
+ * @returns {string[]} found paths value from error.
+ * @version 0.19.0
+ * @since 0.1.0
+ * @private
+ */
+const parseErrorValues = (paths, error) => {
+  // back off if no error message
+  if (!error.message) {
+    return [];
+  }
+
+  // obtain paths value
+  let values = nth(error.message.match(/dup key: { (.+?) }/), 1) || '';
+  values = uniq(
+    [].concat(values.match(/'(.+?)'/g)).concat(values.match(/"(.+?)"/g))
+  ); // enclosed with quotes
+  values = map(values, (v) => v.replace(/^"(.+?)"$/, '$1')); // double quotes
+  values = map(values, (v) => v.replace(/^'(.+?)'$/, '$1')); // single quotes
+  values = paths.length === 1 ? [values.join(' ')] : values;
+
+  // return parsed paths values
+  return values;
+};
+
+/**
+ * @function uniqueErrorPlugin
+ * @name uniqueErrorPlugin
+ * @description Plugin to handle mongodb unique error
+ * @param {object} schema valid mongoose schema
+ * @version 0.2.0
+ * @since 0.1.0
+ * @public
+ */
+export default function uniqueErrorPlugin(schema) {
+  /**
+   * @function handleUniqueError
+   * @name handleUniqueError
+   * @description Handle mongodb unique error and transform to mongoose error
+   * @param {Error|object} error valid mongodb unique error
+   * @param {object} doc valid mongoose document
+   * @param {Function} next callback to invoke on success or error
+   * @returns {Error} valid mongoose error
+   * @version 0.2.0
+   * @since 0.1.0
+   * @private
+   */
+  function handleUniqueError(error, doc, next) {
+    // this: Model instance context
+
+    // obtain current instance
+    const instance = doc || this;
+
+    // continue if is not unique error
+    if (!isUniqueError(error)) {
+      return next(error);
+    }
+
+    // obtain index name
+    const indexName =
+      nth(error.message.match(/index: (.+?) dup key:/), 1) || '';
+
+    // obtain unique paths from error
+    const paths = parseErrorPaths(schema, error);
+
+    // obtain paths value from error
+    const values = parseErrorValues(paths, error);
+
+    // build mongoose validations error bag
+    if (!isEmpty(paths) && !isEmpty(values)) {
+      const errors = {};
+
+      forEach(paths, (pathName, index) => {
+        // construct path error properties
+        let pathValue = nth(values, index);
+        if (isFunction(instance.get)) {
+          pathValue = instance.get(pathName);
+        }
+        const props = {
+          type: 'unique',
+          path: pathName,
+          value: pathValue,
+          message: 'Path `{PATH}` ({VALUE}) is not unique.',
+          reason: error.message,
+          index: indexName,
+        };
+
+        // construct path validation error
+        const pathError = new mongoose.Error.ValidatorError(props);
+        pathError.index = indexName;
+        errors[pathName] = pathError;
+      });
+
+      // build mongoose validation error
+      const err = new mongoose.Error.ValidationError();
+      err.status = err.status || 400;
+      err.errors = errors;
+
+      return next(err);
+    }
+
+    // continue with error
+    return next(error);
+  }
+
+  // plugin unique error handler
+  schema.post('save', handleUniqueError);
+  schema.post('insertMany', handleUniqueError);
+  schema.post('findOneAndReplace', handleUniqueError);
+  schema.post('findOneAndUpdate', handleUniqueError);
+  schema.post('replaceOne', handleUniqueError);
+  schema.post('update', handleUniqueError);
+  schema.post('updateMany', handleUniqueError);
+  schema.post('updateOne', handleUniqueError);
+}

package/src/plugins/path.plugin.js

@@ -0,0 +1,39 @@
+import { forEach, isFunction, split } from 'lodash';
+
+/**
+ * @function path
+ * @name path
+ * @description obtain schema path from model
+ * @param {object} schema valid mongoose schema instance
+ * @version 0.1.0
+ * @since 0.1.0
+ * @public
+ */
+export default (schema) => {
+  // register path
+  const canNotGetPath = !isFunction(schema.statics.path);
+
+  if (canNotGetPath) {
+    // eslint-disable-next-line no-param-reassign
+    schema.statics.path = function path(pathName) {
+      // initalize path
+      let $path;
+
+      // tokenize path
+      const paths = split(pathName, '.');
+
+      // iterate on schema recursive to get path schema
+      forEach(paths, function getPath(part) {
+        // obtain schema to resolve path
+        const $schema = $path ? $path.schema : schema;
+        $path = $schema && $schema.path ? $schema.path(part) : undefined;
+      });
+
+      // fall back to direct path
+      $path = $path || schema.path(pathName);
+
+      // return found path
+      return $path;
+    };
+  }
+};

package/{lib → src/plugins}/seed.plugin.js

@@ -1,52 +1,85 @@
-'use strict';
+import { join as joinPath, resolve as resolvePath } from 'path';
+import {
+  compact,
+  filter,
+  forEach,
+  get,
+  isArray,
+  isEmpty,
+  isFunction,
+  isPlainObject,
+  isString,
+  map,
+  mapValues,
+  noop,
+  omit,
+} from 'lodash';
+import { waterfall, parallel } from 'async';
+import { mergeObjects, idOf } from '@lykmapipo/common';
+import { getBoolean, getString } from '@lykmapipo/env';
+import mongoose from 'mongoose-valid8';
 
-/* dependencies */
-const path = require('path');
-const _ = require('lodash');
-const { waterfall, parallel } = require('async');
-const { mergeObjects, idOf } = require('@lykmapipo/common');
-const { getBoolean, getString } = require('@lykmapipo/env');
-const mongoose = require('mongoose');
-
-const loadPathSeeds = (collectionName) => {
+/**
+ * @name loadPathSeeds
+ * @description load seeds from paths
+ * @param {string} collectionName valid collection name
+ * @returns {object|object[]} given collection seed from a path
+ * @since 0.21.0
+ * @version 0.2.0
+ * @private
+ */
+function loadPathSeeds(collectionName) {
+  // resolve seed path
   const BASE_PATH = getString('BASE_PATH', process.cwd());
-  let SEED_PATH = getString('SEED_PATH', path.join(BASE_PATH, 'seeds'));
-  SEED_PATH = path.resolve(SEED_PATH, collectionName);
+  let SEED_PATH = getString('SEED_PATH', joinPath(BASE_PATH, 'seeds'));
+  SEED_PATH = resolvePath(SEED_PATH, collectionName);
+
+  // try load seeds from path
   try {
+    // eslint-disable-next-line import/no-dynamic-require, global-require
     let seeds = require(SEED_PATH);
     // honor es6 default exports
-    seeds = [].concat(_.isArray(seeds.default) ? seeds.default : seeds);
+    seeds = [].concat(isArray(seeds.default) ? seeds.default : seeds);
     return seeds;
   } catch (e) {
     return [];
   }
-};
-
-const seedModel = function (data, done) {
-  /* jshint validthis: true */
+}
 
+/**
+ * @function clearAndSeedModel
+ * @name clearAndSeedModel
+ * @description clear and seed the given model data
+ * @param {object|object[]|Function} data valid model data
+ * @param {Function} done callback to invoke on success or error
+ * @returns {object} seed results
+ * @since 0.21.0
+ * @version 0.2.0
+ * @private
+ */
+function seedModel(data, done) {
   // this: Model static context
 
   // normalize arguments
   let seeds = [];
-  let cb = _.noop;
-  let filter = (val) => val;
-  let transform = (val) => val;
-  if (_.isFunction(data)) {
+  let cb = noop;
+  let filterFn = (val) => val;
+  let transformFn = (val) => val;
+  if (isFunction(data)) {
     cb = data;
   }
-  if (_.isArray(data)) {
+  if (isArray(data)) {
     seeds = [].concat(data);
   }
-  if (_.isPlainObject(data)) {
-    filter = data.filter || filter;
-    transform = data.transform || transform;
-    seeds = data.data || _.omit(data, 'filter', 'transform');
-    seeds = _.isArray(seeds) ? seeds : mergeObjects(seeds);
+  if (isPlainObject(data)) {
+    filterFn = data.filter || filterFn;
+    transformFn = data.transform || transformFn;
+    seeds = data.data || omit(data, 'filter', 'transform');
+    seeds = isArray(seeds) ? seeds : mergeObjects(seeds);
     seeds = [].concat(seeds);
-    seeds = _.filter(seeds, (seed) => !_.isEmpty(seed));
+    seeds = filter(seeds, (seed) => !isEmpty(seed));
   }
-  if (_.isFunction(done)) {
+  if (isFunction(done)) {
     cb = done || cb;
   }
   // let seeds = _.isFunction(data) ? [] : [].concat(data);
@@ -54,34 +87,34 @@ const seedModel = function (data, done) {
 
   // compact seeds
   const collectionName =
-    _.get(this, 'collection.name') || _.get(this, 'collection.collectionName');
+    get(this, 'collection.name') || get(this, 'collection.collectionName');
 
   // ignore path seeds if seed provided
-  if (_.isEmpty(seeds)) {
+  if (isEmpty(seeds)) {
     const pathSeeds = loadPathSeeds(collectionName);
-    seeds = _.compact([...seeds, ...pathSeeds]);
-    seeds = _.filter(seeds, (seed) => !_.isEmpty(seed));
+    seeds = compact([...seeds, ...pathSeeds]);
+    seeds = filter(seeds, (seed) => !isEmpty(seed));
   }
 
   // filter seeds
-  seeds = _.filter(seeds, filter);
+  seeds = filter(seeds, filterFn);
 
   // transform seeds
-  seeds = _.map(seeds, transform);
+  seeds = map(seeds, transformFn);
 
   // filter empty seeds
-  seeds = _.filter(seeds, (seed) => !_.isEmpty(seed));
+  seeds = filter(seeds, (seed) => !isEmpty(seed));
 
   // find existing instance fullfill seed criteria
   const findExisting = (seed, afterFind) => {
     // map seed to criteria
-    const canProvideCriteria = _.isFunction(this.prepareSeedCriteria);
-    let prepareSeedCriteria = (seed) => seed;
+    const canProvideCriteria = isFunction(this.prepareSeedCriteria);
+    let prepareSeedCriteria = ($seed) => $seed;
     if (canProvideCriteria) {
       prepareSeedCriteria = this.prepareSeedCriteria;
     }
     let criteria = prepareSeedCriteria(seed);
-    criteria = _.omit(criteria, 'populate');
+    criteria = omit(criteria, 'populate');
 
     // find existing data
     return this.findOne(criteria, afterFind);
@@ -93,12 +126,12 @@ const seedModel = function (data, done) {
     const { model, match, select, array } = dependency;
 
     const afterFetchDependency = (error, found) => {
-      const result = _.isEmpty(found) ? undefined : found;
+      const result = isEmpty(found) ? undefined : found;
       return afterDependency(error, result);
     };
 
     // try fetch with provide options
-    if (_.isString(model) && _.isPlainObject(match)) {
+    if (isString(model) && isPlainObject(match)) {
       try {
         const Model = mongoose.model(model);
         if (array) {
@@ -131,20 +164,21 @@ const seedModel = function (data, done) {
     return waterfall(
       [
         (next) => {
-          if (_.isEmpty(ignore)) {
+          if (isEmpty(ignore)) {
             return next(null, []);
           }
-          const ignoreCriteria = _.omit(ignore, 'select');
+          const ignoreCriteria = omit(ignore, 'select');
           return fetchDependency(ignoreCriteria, next);
         }, // fetch ignored
         (ignored, next) => {
           // use ignored
           const ignorePath = ignore.path || '_id';
-          const ignoredIds = _.compact(
-            _.map([].concat(ignored), (val) => idOf(val))
+          const ignoredIds = compact(
+            map([].concat(ignored), (val) => idOf(val))
           );
-          let { model, match, select, array } = mergeObjects(dependency);
-          if (!_.isEmpty(ignoredIds)) {
+          const { model, select, array } = mergeObjects(dependency);
+          let { match } = mergeObjects(dependency);
+          if (!isEmpty(ignoredIds)) {
             match = mergeObjects(
               {
                 [ignorePath]: { $nin: ignoredIds },
@@ -163,8 +197,8 @@ const seedModel = function (data, done) {
   // TODO: optimize queries
   const fetchDependencies = (seed, afterDependencies) => {
     let dependencies = mergeObjects(seed.populate);
-    if (_.isPlainObject(dependencies) && !_.isEmpty(dependencies)) {
-      dependencies = _.mapValues(dependencies, (dependency) => {
+    if (isPlainObject(dependencies) && !isEmpty(dependencies)) {
+      dependencies = mapValues(dependencies, (dependency) => {
         return (afterDependency) => {
           return fetchDependencyExcludeIgnore(dependency, afterDependency);
         };
@@ -175,19 +209,21 @@ const seedModel = function (data, done) {
   };
 
   // merge existing with seed data
-  const mergeOne = (found, data, afterMergeOne) => {
+  const mergeOne = (found, $data, afterMergeOne) => {
     if (found) {
       const SEED_FRESH = getBoolean('SEED_FRESH', false);
       let updates = {};
       if (SEED_FRESH) {
-        updates = mergeObjects(found.toObject(), data);
+        updates = mergeObjects(found.toObject(), $data);
       } else {
-        updates = mergeObjects(data, found.toObject());
+        updates = mergeObjects($data, found.toObject());
       }
       found.set(updates);
+      // eslint-disable-next-line no-param-reassign
       found.updatedAt = new Date();
     } else {
-      found = new this(data);
+      // eslint-disable-next-line no-param-reassign
+      found = new this($data);
     }
     return found.put ? found.put(afterMergeOne) : found.save(afterMergeOne);
   };
@@ -201,7 +237,8 @@ const seedModel = function (data, done) {
             if (error) {
               return next(error);
             }
-            _.forEach(dependencies, (value, key) => {
+            forEach(dependencies, (value, key) => {
+              // eslint-disable-next-line no-param-reassign
               seed[key] = value;
             });
             return next();
@@ -215,48 +252,61 @@ const seedModel = function (data, done) {
   };
 
   // prepare seeds
-  seeds = _.map(seeds, (seed) => {
+  seeds = map(seeds, (seed) => {
     return (next) => upsertOne(seed, next);
   });
 
   // run seeds
   return parallel(seeds, cb);
-};
-
-const clearAndSeedModel = function (data, done) {
-  /* jshint validthis: true */
+}
 
+/**
+ * @function clearAndSeedModel
+ * @name clearAndSeedModel
+ * @description clear and seed the given model data
+ * @param {object|object[]|Function} data valid model data
+ * @param {Function} done callback to invoke on success or error
+ * @returns {object} seed results
+ * @since 0.21.0
+ * @version 0.2.0
+ * @private
+ */
+function clearAndSeedModel(data, done) {
   // this: Model static context
 
   // normalize callback
-  let cb = _.isFunction(data) ? data : done;
+  const cb = isFunction(data) ? data : done;
 
   // clear model data
   const doClear = (next) => this.deleteMany((error) => next(error));
 
   // seed model data
   const doSeed = (next) =>
-    _.isFunction(data) ? this.seed(next) : this.seed(data, next);
+    isFunction(data) ? this.seed(next) : this.seed(data, next);
 
   // run clear then seed
   return waterfall([doClear, doSeed], cb);
-};
+}
 
 /**
- * @function seed
- * @name seed
- * @description extend mongoose schema with seed capability
- * @param {Schema} schema valid mongoose schema instance
+ * @function seedPlugin
+ * @name seedPlugin
+ * @description Extend mongoose schema with seed capability
+ * @param {object} schema valid mongoose schema instance
  * @since 0.21.0
- * @version 0.1.0
+ * @version 0.2.0
+ * @public
  */
-module.exports = exports = (schema) => {
-  const canNotSeed = !_.isFunction(schema.statics.seed);
+export default function seedPlugin(schema) {
+  const canNotSeed = !isFunction(schema.statics.seed);
   if (canNotSeed) {
+    // eslint-disable-next-line no-param-reassign
     schema.statics.seed = seedModel;
+
+    // eslint-disable-next-line no-param-reassign
     schema.statics.clearAndSeed = clearAndSeedModel;
   }
-};
+}
 
 // TODO: async prepareSeedCriteria
 // TODO: prepareSeedCriteria(seed, code)

package/.jsbeautifyrc

@@ -1,7 +0,0 @@
-{
-  "js": {
-    "jslint_happy": true,
-    "indent_size": 2,
-    "wrap_line_length": 80
-  }
-}