@lykmapipo/mongoose-common 0.39.0 → 0.40.0

package/es/index.js

@@ -0,0 +1,1151 @@
+import { isEmpty, nth, forEach, isFunction, map, filter, split, isArray, isPlainObject, omit, get, compact, noop, mapValues, isString as isString$1, isNull, toPlainObject, head, tail } from 'lodash';
+import { createHmac } from 'crypto';
+import { uniq, mergeObjects, idOf, compact as compact$1, join as join$1 } from '@lykmapipo/common';
+import mongoose from 'mongoose-valid8';
+import { toObject } from 'mongoose/lib/utils';
+import { model } from '@lykmapipo/mongoose-connection';
+export { SCHEMA_OPTIONS, SUB_SCHEMA_OPTIONS, clear, collectionNameOf, connect, createModel, createSchema, createSubSchema, createVarySubSchema, disableDebug, disconnect, drop, enableDebug, isAggregate, isConnected, isConnection, isModel, isQuery, isSchema, model, syncIndexes } from '@lykmapipo/mongoose-connection';
+import { join, resolve } from 'path';
+import { waterfall, parallel } from 'async';
+import { getString, getBoolean } from '@lykmapipo/env';
+
+/**
+ * @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
+ */
+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);
+}
+
+/**
+ * @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
+ */
+var pathPlugin = (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;
+    };
+  }
+};
+
+/**
+ * @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', join(BASE_PATH, 'seeds'));
+  SEED_PATH = resolve(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);
+    return seeds;
+  } catch (e) {
+    return [];
+  }
+}
+
+/**
+ * @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 filterFn = (val) => val;
+  let transformFn = (val) => val;
+  if (isFunction(data)) {
+    cb = data;
+  }
+  if (isArray(data)) {
+    seeds = [].concat(data);
+  }
+  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));
+  }
+  if (isFunction(done)) {
+    cb = done || cb;
+  }
+  // let seeds = _.isFunction(data) ? [] : [].concat(data);
+  // const cb = _.isFunction(data) ? data : done;
+
+  // compact seeds
+  const collectionName =
+    get(this, 'collection.name') || get(this, 'collection.collectionName');
+
+  // ignore path seeds if seed provided
+  if (isEmpty(seeds)) {
+    const pathSeeds = loadPathSeeds(collectionName);
+    seeds = compact([...seeds, ...pathSeeds]);
+    seeds = filter(seeds, (seed) => !isEmpty(seed));
+  }
+
+  // filter seeds
+  seeds = filter(seeds, filterFn);
+
+  // transform seeds
+  seeds = map(seeds, transformFn);
+
+  // filter empty seeds
+  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;
+    if (canProvideCriteria) {
+      prepareSeedCriteria = this.prepareSeedCriteria;
+    }
+    let criteria = prepareSeedCriteria(seed);
+    criteria = omit(criteria, 'populate');
+
+    // find existing data
+    return this.findOne(criteria, afterFind);
+  };
+
+  // fetch existing dependency
+  const fetchDependency = (dependency, afterDependency) => {
+    // obtain options
+    const { model, match, select, array } = dependency;
+
+    const afterFetchDependency = (error, found) => {
+      const result = isEmpty(found) ? undefined : found;
+      return afterDependency(error, result);
+    };
+
+    // try fetch with provide options
+    if (isString$1(model) && isPlainObject(match)) {
+      try {
+        const Model = mongoose.model(model);
+        if (array) {
+          return Model.find(
+            match,
+            mergeObjects(select, { _id: 1 }),
+            { autopopulate: false },
+            afterFetchDependency
+          );
+        }
+        return Model.findOne(
+          match,
+          mergeObjects(select, { _id: 1 }),
+          { autopopulate: false },
+          afterFetchDependency
+        );
+      } catch (e) {
+        return afterDependency(e);
+      }
+    }
+
+    // backoff: invalid options
+    return afterDependency(new Error('Invalid Populate Options'));
+  };
+
+  // fetch dependencies exclude ignored
+  const fetchDependencyExcludeIgnore = (dependency, afterDependency) => {
+    // obtain options
+    const { ignore = {} } = dependency;
+    return waterfall(
+      [
+        (next) => {
+          if (isEmpty(ignore)) {
+            return next(null, []);
+          }
+          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 { model, select, array } = mergeObjects(dependency);
+          let { match } = mergeObjects(dependency);
+          if (!isEmpty(ignoredIds)) {
+            match = mergeObjects(
+              {
+                [ignorePath]: { $nin: ignoredIds },
+              },
+              match
+            );
+          }
+          return fetchDependency({ model, match, select, array }, next);
+        }, // fetch dependencies exclude ignored
+      ],
+      afterDependency
+    );
+  };
+
+  // fetch existing seed dependencies
+  // TODO: optimize queries
+  const fetchDependencies = (seed, afterDependencies) => {
+    let dependencies = mergeObjects(seed.populate);
+    if (isPlainObject(dependencies) && !isEmpty(dependencies)) {
+      dependencies = mapValues(dependencies, (dependency) => {
+        return (afterDependency) => {
+          return fetchDependencyExcludeIgnore(dependency, afterDependency);
+        };
+      });
+      return parallel(dependencies, afterDependencies);
+    }
+    return afterDependencies(null, seed);
+  };
+
+  // merge existing with seed data
+  const mergeOne = (found, $data, afterMergeOne) => {
+    if (found) {
+      const SEED_FRESH = getBoolean('SEED_FRESH', false);
+      let updates = {};
+      if (SEED_FRESH) {
+        updates = mergeObjects(found.toObject(), $data);
+      } else {
+        updates = mergeObjects($data, found.toObject());
+      }
+      found.set(updates);
+      // eslint-disable-next-line no-param-reassign
+      found.updatedAt = new Date();
+    } else {
+      // eslint-disable-next-line no-param-reassign
+      found = new this($data);
+    }
+    return found.put ? found.put(afterMergeOne) : found.save(afterMergeOne);
+  };
+
+  // update or create seed
+  const upsertOne = (seed, afterUpsert) => {
+    return waterfall(
+      [
+        (next) => {
+          fetchDependencies(seed, (error, dependencies) => {
+            if (error) {
+              return next(error);
+            }
+            forEach(dependencies, (value, key) => {
+              // eslint-disable-next-line no-param-reassign
+              seed[key] = value;
+            });
+            return next();
+          });
+        },
+        (next) => findExisting(seed, next),
+        (found, next) => mergeOne(found, seed, next),
+      ],
+      afterUpsert
+    );
+  };
+
+  // prepare seeds
+  seeds = map(seeds, (seed) => {
+    return (next) => upsertOne(seed, next);
+  });
+
+  // run seeds
+  return parallel(seeds, cb);
+}
+
+/**
+ * @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
+  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);
+
+  // run clear then seed
+  return waterfall([doClear, doSeed], cb);
+}
+
+/**
+ * @function seedPlugin
+ * @name seedPlugin
+ * @description Extend mongoose schema with seed capability
+ * @param {object} schema valid mongoose schema instance
+ * @since 0.21.0
+ * @version 0.2.0
+ * @public
+ */
+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)
+// TODO: done(error, criteria)
+
+/**
+ * @module mongoose-common
+ * @name mongoose-common
+ * @description Re-usable helpers for mongoose
+ * @author lally elias <lallyelias87@mail.com>
+ * @license MIT
+ * @since  0.1.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * const {
+ *   connect,
+ *   clear,
+ *   drop,
+ *   disconnect,
+ * } = require('@lykmapipo/mongoose-common');
+ *
+ * connect((error) => { ... });
+ * clear((error) => { ... });
+ * drop((error) => { ... });
+ * disconnect((error) => { ... });
+ */
+
+// set global mongoose promise
+mongoose.Promise = global.Promise;
+
+/**
+ * @name path
+ * @description register path schema plugin
+ * @since 0.1.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * const name = User.path('name');
+ * //=> SchemaString { path: 'name', instance: 'String', ... }
+ */
+mongoose.plugin(pathPlugin); // TODO: ignore global
+
+/**
+ * @name error
+ * @description unique error handler schema plugin
+ * @since 0.1.0
+ * @version 0.1.0
+ * @public
+ */
+mongoose.plugin(uniqueErrorPlugin); // TODO: ignore global
+
+/**
+ * @name seed
+ * @description data seed schema plugin
+ * @since 0.21.0
+ * @version 0.1.0
+ * @public
+ */
+mongoose.plugin(seedPlugin); // TODO: ignore global
+
+// expose shortcuts
+const { STATES } = mongoose;
+const { Aggregate } = mongoose;
+const { Collection } = mongoose;
+const { Connection } = mongoose;
+const { Schema } = mongoose;
+const { SchemaType } = mongoose;
+const { SchemaTypes } = mongoose;
+const { VirtualType } = mongoose;
+const { Types } = mongoose;
+const MongooseTypes = mongoose.Types;
+const { Query } = mongoose;
+const MongooseError = mongoose.Error;
+const { CastError } = mongoose;
+const modelNames = () => mongoose.modelNames();
+const { GridFSBucket } = mongoose.mongo;
+
+// schema types shortcuts
+
+const SchemaString = Schema.Types.String;
+const SchemaNumber = Schema.Types.Number;
+const SchemaBoolean = Schema.Types.Boolean;
+const { DocumentArray } = Schema.Types;
+const SchemaDocumentArray = Schema.Types.DocumentArray;
+const SubDocument = Schema.Types.Subdocument;
+const SchemaSubDocument = Schema.Types.Subdocument;
+const Embedded = SubDocument;
+const SchemaEmbedded = SubDocument;
+const SchemaArray = Schema.Types.Array;
+const SchemaBuffer = Schema.Types.Buffer;
+const SchemaDate = Schema.Types.Date;
+const { ObjectId } = Schema.Types;
+const SchemaObjectId = Schema.Types.ObjectId;
+const { Mixed } = Schema.Types;
+const SchemaMixed = Schema.Types.Mixed;
+const { Decimal128 } = Schema.Types;
+const SchemaDecimal = Decimal128;
+const SchemaDecimal128 = Decimal128;
+const SchemaMap = Schema.Types.Map;
+
+/**
+ * @name LOOKUP_FIELDS
+ * @description Common lookup fields used in aggregation
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.13.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * const { LOOKUP_FIELDS } = require('@lykmapipo/mongoose-common');
+ * //=> ['from', 'localField', 'foreignField', 'as']
+ */
+const LOOKUP_FIELDS = ['from', 'localField', 'foreignField', 'as'];
+
+/**
+ * @function toCollectionName
+ * @name toCollectionName
+ * @description Produces a collection name of provided model name
+ * @param {string} modelName a model name
+ * @returns {string} a collection name
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.8.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * const collectionName = toCollectionName('User');
+ * //=> users
+ */
+const toCollectionName = (modelName) => {
+  let collectionName = modelName;
+  if (!isEmpty(modelName)) {
+    collectionName = mongoose.pluralize()(modelName);
+  }
+  return collectionName;
+};
+
+/**
+ * @function isObjectId
+ * @name isObjectId
+ * @description Check if provided value is an instance of ObjectId
+ * @param {Mixed} val value to check if its an ObjectId
+ * @author lally elias <lallyelias87@mail.com>
+ * @returns {boolean} whether a val is ObjectId instance
+ * @since 0.2.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * isObjectId(val);
+ * //=> true
+ */
+const isObjectId = (val) => {
+  const $isObjectId = val instanceof mongoose.Types.ObjectId;
+  return $isObjectId;
+};
+
+/**
+ * @function isMap
+ * @name isMap
+ * @description Check if provided value is an instance of Map
+ * @param {Mixed} val value to check if its a Map
+ * @author lally elias <lallyelias87@mail.com>
+ * @returns {boolean} whether a val is Map instance
+ * @since 0.2.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * isMap(val);
+ * //=> true
+ */
+const isMap = (val) => {
+  const $isMap = val instanceof mongoose.Types.Map;
+  return $isMap;
+};
+
+/**
+ * @function isString
+ * @name isString
+ * @description Check if provided value is an instance of String schema type
+ * @param {Mixed} val value to check if its a String schema type
+ * @author lally elias <lallyelias87@mail.com>
+ * @returns {boolean} whether a val is String instance
+ * @since 0.10.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * isString(val);
+ * //=> true
+ */
+const isString = (val) => {
+  const $isString = val instanceof Schema.Types.String;
+  return $isString;
+};
+
+/**
+ * @function isArraySchemaType
+ * @name isArraySchemaType
+ * @description check if schema type is array
+ * @param {SchemaType} val valid mongoose schema type
+ * @returns {boolean} whether schema type is array
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.16.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * isArraySchemaType(val)
+ * //=> true
+ */
+const isArraySchemaType = (val = {}) => {
+  const { $isMongooseArray = false, instance } = val;
+  const isArray =
+    val instanceof Schema.Types.Array ||
+    $isMongooseArray ||
+    instance === 'Array';
+  return isArray;
+};
+
+/**
+ * @function isStringArray
+ * @name isStringArray
+ * @description Check if provided value is an instance of StringArray
+ * schema type
+ * @param {Mixed} val value to check if its a StringArray schema type
+ * @author lally elias <lallyelias87@mail.com>
+ * @returns {boolean} whether a val is String Array instance
+ * @since 0.11.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * isStringArray(val);
+ * //=> true
+ */
+const isStringArray = (val) => {
+  const $isStringArray =
+    val &&
+    val instanceof Schema.Types.Array &&
+    val.caster instanceof Schema.Types.String;
+  return $isStringArray;
+};
+
+/**
+ * @function isNumber
+ * @name isNumber
+ * @description Check if provided value is an instance of Number schema type
+ * @param {Mixed} val value to check if its a Number schema type
+ * @author lally elias <lallyelias87@mail.com>
+ * @returns {boolean} whether a val is Number instance
+ * @since 0.10.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * isNumber(<val>);
+ * //=> true
+ */
+const isNumber = (val) => {
+  const $isNumber = val instanceof Schema.Types.Number;
+  return $isNumber;
+};
+
+/**
+ * @function isNumberArray
+ * @name isNumberArray
+ * @description Check if provided value is an instance of NumberArray
+ * schema type
+ * @param {Mixed} val value to check if its a NumberArray schema type
+ * @author lally elias <lallyelias87@mail.com>
+ * @returns {boolean} whether a val is Number Array instance
+ * @since 0.11.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * isNumberArray(val);
+ * //=> true
+ */
+const isNumberArray = (val) => {
+  const $isNumberArray =
+    val &&
+    val instanceof Schema.Types.Array &&
+    val.caster instanceof Schema.Types.Number;
+  return $isNumberArray;
+};
+
+/**
+ * @function isInstance
+ * @name isInstance
+ * @description check if object is valid mongoose model instance
+ * @param {object} value valid object
+ * @returns {boolean} whether object is valid model instance
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.4.0
+ * @version 0.2.0
+ * @public
+ * @example
+ *
+ * isInstance(val);
+ * //=> true
+ */
+const isInstance = (value) => {
+  if (value) {
+    const $isInstance =
+      isFunction(get(value, 'toObject', null)) &&
+      !isNull(get(value, '$__', null));
+    return $isInstance;
+  }
+  return false;
+};
+
+/**
+ * @name copyInstance
+ * @description copy and return plain object of mongoose model instance
+ * @param {object} value valid object
+ * @returns {object} plain object from mongoose model instance
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.4.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * const instance = copyInstance(val);
+ * //=> { ... }
+ */
+const copyInstance = (value = {}) => mergeObjects(toObject(value));
+
+/**
+ * @function schemaTypeOptionOf
+ * @name schemaTypeOptionOf
+ * @description obtain schema type options
+ * @param {SchemaType} schemaType valid mongoose schema type
+ * @returns {object} schema type options
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.14.0
+ * @version 0.1.0
+ * @private
+ * @example
+ *
+ * const options = schemaTypeOptionOf(schemaType)
+ * //=> { trim: true, ... }
+ */
+const schemaTypeOptionOf = (schemaType = {}) => {
+  // grab options
+  const options = mergeObjects(
+    // grub schema caster options
+    toPlainObject(get(schemaType, 'caster.options')),
+    // grab direct schema options
+    toPlainObject(get(schemaType, 'options'))
+  );
+  // return options
+  return options;
+};
+
+/**
+ * @function eachPath
+ * @name eachPath
+ * @description iterate recursively on schema primitive paths and invoke
+ * provided iteratee function.
+ * @param {object} schema valid instance of mongoose schema
+ * @param {Function} iteratee callback function invoked per each path found.
+ * The callback is passed the pathName, parentPath and schemaType as arguments
+ * on each iteration.
+ * @see {@link https://mongoosejs.com/docs/api.html#schema_Schema-eachPath}
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.1.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * eachPath(schema, (path, schemaType) => { ... });
+ */
+const eachPath = (schema, iteratee) => {
+  /**
+   * @name iterateRecursive
+   * @description recursivily search for a schema path
+   * @param {string} pathName valid schema path name
+   * @param {object} schemaType valid schema type
+   * @param {string} parentPath parent schema path
+   */
+  function iterateRecursive(pathName, schemaType, parentPath) {
+    // compute path name
+    const $path = compact$1([parentPath, pathName]).join('.');
+
+    // check if is sub schema
+    const $isSchema =
+      schemaType.schema && isFunction(schemaType.schema.eachPath);
+
+    // iterate over sub schema
+    if ($isSchema) {
+      const { schema: subSchema } = schemaType;
+      subSchema.eachPath(function iterateSubSchema($pathName, $schemaType) {
+        iterateRecursive($pathName, $schemaType, $path);
+      });
+    }
+
+    // invoke iteratee
+    else {
+      iteratee($path, schemaType);
+    }
+  }
+
+  // iterate recursive
+  schema.eachPath(function iterateParentSchema(pathName, schemaType) {
+    iterateRecursive(pathName, schemaType);
+  });
+};
+
+/**
+ * @function jsonSchema
+ * @name jsonSchema
+ * @description Produces valid json schema of all available models
+ * if `mongoose-schema-jsonschema` has been applied
+ * @author lally elias <lallyelias87@mail.com>
+ * @returns {object[]} models json schema
+ * @since 0.8.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * const jsonSchema = jsonSchema();
+ * //=> {"user": {title: "User", type: "object", properties: {..} } }
+ */
+const jsonSchema = () => {
+  // initialize schemas dictionary
+  const schemas = {};
+  // get model names
+  const $modelNames = mongoose.modelNames();
+  // loop model names to get schemas
+  forEach($modelNames, function getJsonSchema(modelName) {
+    // get model
+    const Model = model(modelName);
+    // collect model json schema
+    if (Model && isFunction(Model.jsonSchema)) {
+      schemas[modelName] = Model.jsonSchema();
+    }
+  });
+  // return available schemas
+  return schemas;
+};
+
+/**
+ * @function validationErrorFor
+ * @name validationErrorFor
+ * @description Create mongoose validation error for specified options
+ * @param {object} optns valid error options
+ * @param {number | string} [optns.status] valid error status
+ * @param {number | string} [optns.code] valid error code
+ * @param {object} [optns.paths] paths with validator error properties
+ * @returns {object} valid instance of mongoose validation error
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.24.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * const status = 400;
+ * const paths = {
+ *   name: { type: 'required', path:'name', value: ..., message: ...  }
+ * };
+ * const error = validationErrorFor({ status, paths });
+ * //=> error
+ */
+const validationErrorFor = (optns) => {
+  // obtain options
+  const { status = 400, code = 400, paths = {} } = mergeObjects(optns);
+
+  // create mongoose validation error
+  const error = new mongoose.Error.ValidationError();
+  error.status = status;
+  error.code = code || status;
+  // eslint-disable-next-line no-underscore-dangle
+  error.message = error.message || error._message;
+
+  // attach path validator error
+  if (!isEmpty(paths)) {
+    const errors = {};
+    forEach(paths, (props, path) => {
+      let pathError = mergeObjects({ path }, props);
+      pathError = new mongoose.Error.ValidatorError(pathError);
+      errors[path] = pathError;
+    });
+    error.errors = errors;
+  }
+
+  // return validation error
+  return error;
+};
+
+/**
+ * @function areSameInstance
+ * @name areSameInstance
+ * @description check if given two mongoose model instances are same
+ * @param {object} a valid model instance
+ * @param {object} b valid model instance
+ * @returns {boolean} whether model instance are same
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.31.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * areSameInstance(a, a); //=> true
+ */
+const areSameInstance = (a, b) => {
+  try {
+    const areSame = !!(a && b && a.equals(b));
+    return areSame;
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * @function areSameObjectId
+ * @name areSameObjectId
+ * @description check if given two mongoose objectid are same
+ * @param {object} a valid object id
+ * @param {object} b valid object
+ * @returns {boolean} whether objectid's are same
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.31.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * areSameObjectId(a, a); //=> true
+ */
+const areSameObjectId = (a, b) => {
+  try {
+    // grab actual ids
+    const idOfA = idOf(a) || a;
+    const idOfB = idOf(b) || b;
+
+    // convert to string
+    const idA = isObjectId(idOfA) ? idOfA.toString() : idOfA;
+    const idB = isObjectId(idOfB) ? idOfB.toString() : idOfB;
+
+    // check if are equal
+    const areSame = idA === idB;
+    return areSame;
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * @function toObjectIds
+ * @name toObjectIds
+ * @description convert given model instances into object ids
+ * @param {...object} instances valid model instances
+ * @returns {object[]} objectid's of model instances
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.31.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * toObjectIds(a, b); //=> [ '5e90486301de071ca4ebc03d', ... ]
+ */
+const toObjectIds = (...instances) => {
+  const ids = map([...instances], (instance) => {
+    const id = idOf(instance) || instance;
+    return id;
+  });
+  return ids;
+};
+
+/**
+ * @function toObjectIdStrings
+ * @name toObjectIdStrings
+ * @description convert given model instances objectid's into strings
+ * @param {...object} instances valid model instances
+ * @returns {string[]} objectid's as strings
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.31.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * toObjectIdStrings(a, b); //=> [ '5e90486301de071ca4ebc03d', ... ]
+ */
+const toObjectIdStrings = (...instances) => {
+  const ids = toObjectIds(...instances);
+  const idStrings = map([...ids], (id) => {
+    const idString = isObjectId(id) ? id.toString() : id;
+    return idString;
+  });
+  return idStrings;
+};
+
+/**
+ * @function objectIdFor
+ * @name objectIdFor
+ * @description create a unique objectid of a given model values
+ * @param {...string} modelName valid model name
+ * @param {...string} parts values to generate object id for
+ * @returns {object} valid objectid
+ * @author lally elias <lallyelias87@mail.com>
+ * @since 0.36.0
+ * @version 0.1.0
+ * @public
+ * @example
+ *
+ * objectIdFor('Party', 'TZ-0101');
+ * //=> '5e90486301de071ca4ebc03d'
+ */
+const objectIdFor = (modelName, ...parts) => {
+  // ensure parts
+  const values = compact$1([].concat(modelName).concat(...parts));
+
+  // ensure secret & message
+  const secret = head(values);
+  const data = join$1(tail(values), ':');
+
+  // generate 24-byte hex hash
+  const hash = createHmac('md5', secret)
+    .update(data)
+    .digest('hex')
+    .slice(0, 24);
+
+  // create objectid from hash
+  const objectId = mongoose.Types.ObjectId.createFromHexString(hash);
+
+  return objectId;
+};
+
+export { Aggregate, CastError, Collection, Connection, Decimal128, DocumentArray, Embedded, GridFSBucket, LOOKUP_FIELDS, Mixed, MongooseError, MongooseTypes, ObjectId, Query, STATES, Schema, SchemaArray, SchemaBoolean, SchemaBuffer, SchemaDate, SchemaDecimal, SchemaDecimal128, SchemaDocumentArray, SchemaEmbedded, SchemaMap, SchemaMixed, SchemaNumber, SchemaObjectId, SchemaString, SchemaSubDocument, SchemaType, SchemaTypes, SubDocument, Types, VirtualType, areSameInstance, areSameObjectId, copyInstance, eachPath, isArraySchemaType, isInstance, isMap, isNumber, isNumberArray, isObjectId, isString, isStringArray, jsonSchema, modelNames, objectIdFor, schemaTypeOptionOf, toCollectionName, toObjectIdStrings, toObjectIds, validationErrorFor };