cosa 6.0.0 → 6.2.0

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 Losant IoT, Inc.
+Copyright (c) 2022 Losant IoT, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/array.js

@@ -4,81 +4,73 @@ const Immutable = require('./immutable');
 /**
  * Immutable handler used to wrap a javascript array.
  * @name ImmutableArray
- * @param {object} data 
- * @param {object} builder 
- * @param {object} options
+ * @param {object} data - Underlying array
+ * @param {object} builder - Builder instance
+ * @param {object} options - Optional settings
+ * @returns {undefined} no return value
  */
-module.exports = function (data, builder, options) {
+module.exports = function(data, builder, options) {
   builder.type = 'Array';
 
   builder.defineProperty('length', data.length);
 
-  const itemDefinition = options.definition ? options.definition.items || {} : {};
+  const itemDefinition = options?.definition?.items || {};
   const itemOptions = { definition: itemDefinition, clone: false };
 
-
-  ['forEach', 'map', 'filter', 'some', 'every'].forEach(function (name) {
-    builder.defineMethod(name, function (cb, thisArg) {
-      var immuArr = Immutable.create(data, options);
-      return Immutable.create(Array.prototype[name].call(data, function (val, index) {
+  ['forEach', 'map', 'filter', 'some', 'every'].forEach(function(name) {
+    builder.defineMethod(name, function(cb, thisArg) {
+      const immuArr = Immutable.create(data, options);
+      return Immutable.create(Array.prototype[name].call(data, function(val, index) {
         return cb.call(thisArg, Immutable.create(val, itemOptions), index, immuArr);
       }));
     });
   });
 
-  ['reduce', 'reduceRight'].forEach(function (name) {
-    builder.defineMethod(name, function (cb, initialValue) {
-      var immuArr = Immutable.create(data, options);
-      return Immutable.create(Array.prototype[name].call(data, function (prev, cur, index) {
+  ['reduce', 'reduceRight'].forEach(function(name) {
+    builder.defineMethod(name, function(cb, initialValue) {
+      const immuArr = Immutable.create(data, options);
+      return Immutable.create(Array.prototype[name].call(data, function(prev, cur, index) {
         return cb(Immutable.create(prev), Immutable.create(cur, itemOptions), index, immuArr);
       }), initialValue);
     });
   });
 
   ['concat', 'join', 'slice', 'indexOf', 'lastIndexOf', 'reverse',
-  'toString', 'toLocaleString'].forEach(function (name) {
-    builder.defineMethod(name, function () {
-      return Immutable.create(Array.prototype[name].apply(data, arguments), options);
+    'toString', 'toLocaleString'].forEach(function(name) {
+    builder.defineMethod(name, function(...rest) {
+      return Immutable.create(Array.prototype[name].apply(data, rest), options);
     });
   });
 
-  builder.defineMethod('push', function () {
-    return Immutable.create(Array.prototype.concat.apply(data, arguments), options);
+  builder.defineMethod('push', function(...rest) {
+    return Immutable.create(Array.prototype.concat.apply(data, rest), options);
   });
 
-  builder.defineMethod('unshift', function () {
-    var args = Array(arguments.length);
-    for (var i = 0, l = arguments.length; i < l; i++) {
-      args[i] = arguments[i];
-    }
-    return Immutable.create(args.concat(data), options);
+  builder.defineMethod('unshift', function(...rest) {
+    return Immutable.create(rest.concat(data), options);
   });
 
-  builder.defineMethod('sort', function (cb) {
-    var newArr = clone(data);
+  builder.defineMethod('sort', function(cb) {
+    const newArr = clone(data);
     if (!cb) {
       return Immutable.create(newArr.sort(), options);
     }
-    return Immutable.create(newArr.sort(function (a, b) {
+    return Immutable.create(newArr.sort(function(a, b) {
       return cb(Immutable.create(a, itemOptions), Immutable.create(b, itemOptions));
     }));
   });
 
-  builder.defineMethod('splice', function () {
-    var args = Array(arguments.length);
-    for (var i = 0, l = arguments.length; i < l; i++) {
-      args[i] = arguments[i];
-    }
-    var start = args[0];
-    var deleteCount = args[1];
-    var items = args.slice(2) || [];
-    var front = data.slice(0, start);
-    var back = data.slice(start + deleteCount);
+  builder.defineMethod('splice', function(...rest) {
+    const start = rest[0];
+    const deleteCount = rest[1];
+    const items = rest.slice(2) || [];
+    const front = data.slice(0, start);
+    const back = data.slice(start + deleteCount);
     return Immutable.create(front.concat(items, back), options);
   });
 
-  builder.defineMethod('reverse', function () {
-    var newArr = clone(data);
+  builder.defineMethod('reverse', function() {
+    const newArr = clone(data);
     return Immutable.create(newArr.reverse(), options);
   });
 };

package/lib/date.js

@@ -1,48 +1,41 @@
-var Immutable = require('./immutable');
+const Immutable = require('./immutable');
 
 /**
  * Immutable handler used to wrap javascript Dates.
  * @name ImmutableDate
- * @param {object} data 
- * @param {object} builder 
- * @param {object} options
+ * @param {object} data - Underlying date
+ * @param {object} builder - Builder instance
+ * @param {object} options - Optional settings
+ * @returns {undefined} no return value
  */
-module.exports = function (data, builder, options) {
+module.exports = function(data, builder, options) {
   builder.type = 'Date';
 
-  builder.defineMethod('mutate', function (cb) {
-    var newDate = new Date(data.valueOf());
+  builder.defineMethod('mutate', function(cb) {
+    const newDate = new Date(data.valueOf());
     cb.apply(newDate);
     return Immutable.create(newDate, { clone: false });
   });
 
   ['toString', 'toISOString', 'toUTCString', 'toDateString', 'toTimeString',
-  'toLocaleString', 'toLocaleDateString', 'toLocaleTimeString', 'valueOf',
-  'getTime', 'getFullYear', 'getUTCFullYear', 'toGMTString', 'getMonth',
-  'getUTCMonth', 'getDate', 'getUTCDate', 'getDay', 'getUTCDay', 'getHours',
-  'getUTCHours', 'getMinutes', 'getUTCMinutes', 'getSeconds', 'getUTCSeconds',
-  'getMilliseconds', 'getUTCMilliseconds', 'getTimezoneOffset', 'getYear',
-  'toJSON'].forEach(function (name) {
-    builder.defineMethod(name, function () {
-      var args = Array(arguments.length);
-      for (var i = 0, l = args.length; i < l; i++) {
-        args[i] = arguments[i];
-      }
-      return Date.prototype[name].apply(data, args);
+    'toLocaleString', 'toLocaleDateString', 'toLocaleTimeString', 'valueOf',
+    'getTime', 'getFullYear', 'getUTCFullYear', 'toGMTString', 'getMonth',
+    'getUTCMonth', 'getDate', 'getUTCDate', 'getDay', 'getUTCDay', 'getHours',
+    'getUTCHours', 'getMinutes', 'getUTCMinutes', 'getSeconds', 'getUTCSeconds',
+    'getMilliseconds', 'getUTCMilliseconds', 'getTimezoneOffset', 'getYear',
+    'toJSON'].forEach(function(name) {
+    builder.defineMethod(name, function(...rest) {
+      return Date.prototype[name].apply(data, rest);
     });
   });
 
   ['setTime', 'setMilliseconds', 'setUTCMilliseconds', 'setSeconds',
-  'setUTCSeconds', 'setMinutes', 'setUTCMinutes', 'setHours', 'setUTCHours',
-  'setDate', 'setUTCDate', 'setMonth', 'setUTCMonth', 'setFullYear',
-  'setUTCFullYear', 'setYear'].forEach(function (name) {
-    builder.defineMethod(name, function () {
-      var args = Array(arguments.length);
-      for (var i = 0, l = args.length; i < l; i++) {
-        args[i] = arguments[i];
-      }
-      var newDate = new Date(data.valueOf());
-      newDate[name].apply(newDate, args);
+    'setUTCSeconds', 'setMinutes', 'setUTCMinutes', 'setHours', 'setUTCHours',
+    'setDate', 'setUTCDate', 'setMonth', 'setUTCMonth', 'setFullYear',
+    'setUTCFullYear', 'setYear'].forEach(function(name) {
+    builder.defineMethod(name, function(...rest) {
+      const newDate = new Date(data.valueOf());
+      newDate[name].apply(newDate, rest);
       return Immutable.create(newDate, options);
     });
   });

package/lib/db.js

@@ -1,10 +1,9 @@
 const debug = require('debug')('cosa:db');
-const defaults = require('defaults');
 const { ObjectId } = require('bson');
 const { EventEmitter } = require('events');
 const { MongoClient } = require('mongodb');
 const {
-  curry, split, last, pipe, isEmpty, clamp, isPlainObject
+  curry, split, last, pipe, clamp, isPlainObject, isNilOrEmpty
 } = require('omnibelt');
 const Immutable = require('./immutable');
 const RESULT_FIELDS = [ 'insertedId', 'insertedCount', 'insertedIds', 'matchedCount', 'modifiedCount', 'upsertedCount', 'upsertedId', 'deletedCount', 'upsertedIds' ];
@@ -111,7 +110,7 @@ class Database extends EventEmitter {
     try {
       this._client = new MongoClient(this._uri);
       this._client = await this._client.connect();
-      let opts;
+      const opts = {};
       if (process.env.COSA_DB_READ_PREFERENCE) {
         opts.readPreference = process.env.COSA_DB_READ_PREFERENCE;
       }
@@ -180,55 +179,70 @@ class Database extends EventEmitter {
    * @param {object} [options.count=false] - get a count of the items, instead of the items themselves.
    * @param {object} [options.findOne=false] - Should a single item be returned.
    * @param {object} [options.readPreference] - the read preference for the query with one of the read constants
+   * @param {number} [options.batchSize] - number of items per batch (default in mongo driver is 1000)
+   * @param {boolean} [options.noCursorTimeout] - boolan, if the cursor can time out after being idle, mongo driver default is false
+   * @param {number} [options.maxTimeMS] - maximum amount of time (in ms) this cursor is allowed to live
+   * @param {object} [options.session] - Mongo session or Cosa Mongo session wrapper
    * @returns {Cursor} returns Cursor object
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/findcursor.html}
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#find}
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#findOne}
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#count}
-   * @see {@link https://github.com/mongodb/node-mongodb-native/blob/357cbf689735c2447bfb05d73c142f1a5b88ca91/lib/read_preference.js#L69}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/findoptions.html#readpreference}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/findoptions.html#batchsize}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/findoptions.html#nocursortimeout}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/findoptions.html#maxtimems}
    */
-  async find(collectionName, query, options) {
-    options = defaults(options, {
-      projection: undefined,
-      sort: undefined,
-      skip: undefined,
-      limit: options && options.count ? null : 1000,
-      count: false,
-      findOne: false,
-      readPreference: undefined
-    });
+  async find(collectionName, query, options = {}) {
     query = deserialize(query);
-    debug('getting db collection');
     const collection = await this.collection(collectionName);
+    const session = options.session?.mongoSession || options.session;
     if (options.count) {
-      const countOptions = { limit: options.limit, skip: options.skip };
-      debug(`db.${collection.collectionName}.countDocuments`, query, countOptions);
-      if (!query || isEmpty(query)) {
-        const count = await collection.estimatedDocumentCount();
+      if (isNilOrEmpty(query) && !session) {
+        const countOptions = {
+          readPreference: options.readPreference,
+          maxTimeMS: options.maxTimeMS
+        };
+        debug(`db.${collection.collectionName}.estimatedDocumentCount`, query, countOptions);
+        const count = await collection.estimatedDocumentCount(countOptions);
         return clamp(0, options.limit || Infinity, count - (options.skip || 0));
       } else {
-        return collection.countDocuments(query, options);
+        const countOptions = {
+          limit: options.limit,
+          skip: options.skip,
+          readPreference: options.readPreference,
+          maxTimeMS: options.maxTimeMS,
+          session
+        };
+        debug(`db.${collection.collectionName}.countDocuments`, query, countOptions);
+        return collection.countDocuments(query, countOptions);
       }
     } else if (options.findOne) {
       const findOptions = {
         projection: options.projection || options.fields,
-        limit: options.limit,
         skip: options.skip,
         sort: options.sort,
-        readPreference: options.readPreference
+        readPreference: options.readPreference,
+        noCursorTimeout: options.noCursorTimeout,
+        maxTimeMS: options.maxTimeMS,
+        session
       };
       debug(`db.${collection.collectionName}.findOne`, query, findOptions);
-      return collection.findOne(query, options);
+      return collection.findOne(query, findOptions);
     } else {
       const findOptions = {
         projection: options.projection || options.fields,
-        limit: options.limit,
+        limit: options.limit === undefined ? 1000 : options.limit,
         skip: options.skip,
         sort: options.sort,
-        readPreference: options.readPreference
+        readPreference: options.readPreference,
+        batchSize: options.batchSize,
+        noCursorTimeout: options.noCursorTimeout,
+        maxTimeMS: options.maxTimeMS,
+        session
       };
-      debug(`db.${collection.collectionName}.find (toArray)`, query, findOptions);
-      return collection.find(query, options);
+      debug(`db.${collection.collectionName}.find`, query, findOptions);
+      return collection.find(query, findOptions);
     }
   }
 
@@ -237,20 +251,20 @@ class Database extends EventEmitter {
    * @param {string} collectionName - Name of the collection.
    * @param {(object|Array)} docs - Documents objects to insert.
    * @param {object} options - options on insert
-   * @param {object} [options.writeConcern] - the write conern options https://mongodb.github.io/node-mongodb-native/4.0/classes/writeconcern.html
+   * @param {object} [options.writeConcern] - the write concern
+   * @param {object} [options.session] - Mongo session or Cosa Mongo session wrapper
    * @returns {Promise} resolves with an object with results, and ops as keys
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#insertmany}
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#insertOne}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/insertoneoptions.html#writeconcern}
    */
-  async insert(collectionName, docs, options) {
-    debug('getting db collection');
+  async insert(collectionName, docs, { writeConcern, session } = {}) {
     docs = deserialize(docs);
     const collection = await this.collection(collectionName);
-    let insertOpts;
-    if (options?.writeConcern) {
-      insertOpts = { writeConcern: options.writeConcern };
-    }
-    const results = await insertOneOrMany(collection, Array.isArray(docs), docs, insertOpts);
+    const results = await insertOneOrMany(collection, Array.isArray(docs), docs, {
+      writeConcern,
+      session: session?.mongoSession || session
+    });
 
     if (Array.isArray(docs)) {
       docs.forEach((doc, i) => {
@@ -271,26 +285,23 @@ class Database extends EventEmitter {
    * @param {object} update - Document properties to update.
    * @param {object} [options] - Optional settings see mongo documentation
    * @param {boolean} [options.multiple=false] - Should multiple documents be updated.
-   * @param {boolean} [options.upsert=false] - Should documents be inserted if they don't already exist..
-   * @param {object} [options.writeConcern] - the write conern options https://mongodb.github.io/node-mongodb-native/4.0/classes/writeconcern.html
+   * @param {boolean} [options.upsert=false] - Should documents be inserted if they don't already exist.
+   * @param {object} [options.writeConcern] - the write concern options
+   * @param {object} [options.session] - Mongo session or Cosa Mongo session wrapper
    * @returns {Promise} resolves with an object with results, and ops as keys
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#updateMany}
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#updateOne}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/updateoptions.html#writeconcern}
    */
-  async update(collectionName, query, update, options) {
-    options = defaults(options, {
-      multiple: false,
-      upsert: false
-    });
-    debug('getting db collection');
+  async update(collectionName, query, update, options = {}) {
     query = deserialize(query);
     update = deserialize(update);
     const collection = await this.collection(collectionName);
-    const updateOptions = { upsert: options.upsert };
-    if (options.writeConcern) {
-      updateOptions.writeConcern = options.writeConcern;
-    }
-    return updateOneOrMany(collection, options.multiple, query, update, updateOptions);
+    return updateOneOrMany(collection, options.multiple, query, update, {
+      upsert: options.upsert,
+      writeConcern: options.writeConcern,
+      session: options.session?.mongoSession || options.session
+    });
   }
 
   /**
@@ -299,23 +310,20 @@ class Database extends EventEmitter {
    * @param {object} query - Query to find which documents to remove.
    * @param {object} [options] - Optional settings see mongo documentation
    * @param {boolean} [options.multiple=false] - Should multiple documents be removed.
-   * @param {object} [options.writeConcern] - the write conern options https://mongodb.github.io/node-mongodb-native/4.0/classes/writeconcern.html
+   * @param {object} [options.writeConcern] - the write concern options
+   * @param {object} [options.session] - Mongo session or Cosa Mongo session wrapper
    * @returns {Promise} resolves with an object with results, and ops as keys
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#deleteMany}
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#deleteOne}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/deleteoptions.html#writeconcern}
    */
-  async remove(collectionName, query, options) {
-    options = defaults(options, {
-      multiple: false
-    });
-    debug('getting db collection');
+  async remove(collectionName, query, options = {}) {
     query = deserialize(query);
     const collection = await this.collection(collectionName);
-    let removeOpts;
-    if (options.writeConcern) {
-      removeOpts = { writeConcern: options.writeConcern };
-    }
-    return deleteOneOrMany(collection, options.multiple, query, removeOpts);
+    return deleteOneOrMany(collection, options.multiple, query, {
+      writeConcern: options.writeConcern,
+      session: options.session?.mongoSession || options.session
+    });
   }
 
   /**
@@ -323,19 +331,24 @@ class Database extends EventEmitter {
    * @param {string} collectionName - Name of the collection.
    * @param {object} pipeline - Aggregation pipeline.
    * @param {object} [options] - Optional settings see mongo documentation
-   * @param {boolean} [options.explain=false] - Should should the execution plan be returned.
-   * @param {object} [options.readPreference] - the read preference for the query
+   * @param {object} [options.readPreference] - the read preference for the query with one of the read constants
+   * @param {number} [options.batchSize] - number of items per batch (default in mongo driver is 1000)
+   * @param {number} [options.maxTimeMS] - maximum amount of time (in ms) this cursor is allowed to live
+   * @param {object} [options.session] - Mongo session or Cosa Mongo session wrapper
    * @returns {Promise} resolves with the result of the aggregation from mongo
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#aggregate}
-   * @see {@link https://github.com/mongodb/node-mongodb-native/blob/357cbf689735c2447bfb05d73c142f1a5b88ca91/lib/read_preference.js#L69}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/aggregateoptions.html#readpreference}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/aggregateoptions.html#batchsize}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/aggregateoptions.html#maxtimems}
    */
-  async aggregate(collectionName, pipeline, options) {
-    options = defaults(options, {
-      explain: undefined // do not use false that will actually cause an explain. https://github.com/mongodb/node-mongodb-native/pull/2626/files#diff-17118eb51bf767027b48c4456850f1b0b9efcd4be4322b5f26898a42731e4621R28
-    });
-    debug('getting db collection');
+  async aggregate(collectionName, pipeline, options = {}) {
     const collection = await this.collection(collectionName);
-    return collection.aggregate(pipeline, options);
+    return collection.aggregate(pipeline, {
+      readPreference: options.readPreference,
+      batchSize: options.batchSize,
+      maxTimeMS: options.maxTimeMS,
+      session: options.session?.mongoSession || options.session
+    });
   }
 
   /**
@@ -345,15 +358,21 @@ class Database extends EventEmitter {
    * @param {object} query - Query to find which documents evaluate.
    * @param {object} [options] - Optional settings see mongo documentation
    * @param {string} [options.readPreference] - the read preference for the query
+   * @param {number} [options.maxTimeMS] - maximum amount of time (in ms) this cursor is allowed to live
+   * @param {object} [options.session] - Mongo session or Cosa Mongo session wrapper
    * @returns {Promise} resolves with the result of the distinct query from mongo
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/classes/collection.html#distinct}
-   * @see {@link https://github.com/mongodb/node-mongodb-native/blob/357cbf689735c2447bfb05d73c142f1a5b88ca91/lib/read_preference.js#L69}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/commandoperationoptions.html#readpreference}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/commandoperationoptions.html#maxtimems}
    */
-  async distinct(collectionName, key, query, options) {
-    debug('getting db collection');
+  async distinct(collectionName, key, query, options = {}) {
     query = deserialize(query);
     const collection = await this.collection(collectionName);
-    return collection.distinct(key, query, options);
+    return collection.distinct(key, query, {
+      readPreference: options.readPreference,
+      maxTimeMS: options.maxTimeMS,
+      session: options.session?.mongoSession || options.session
+    });
   }
 
   /**
@@ -362,25 +381,25 @@ class Database extends EventEmitter {
    * @param {object} query - Query to find which documents evaluate.
    * @param {object} replace - doc to save on the collection
    * @param {object} [options] - Optional settings see mongo documentation
-   * @param {object} [options.writeConcern] - the write conern options https://mongodb.github.io/node-mongodb-native/4.0/classes/writeconcern.html
+   * @param {object} [options.writeConcern] - the write concern options
+   * @param {object} [options.session] - Mongo session or Cosa Mongo session wrapper
    * @returns {Promise} resolves with the result of the distinct query from mongo
    * @see {@link http://mongodb.github.io/node-mongodb-native/3.0/api/Collection.html#replace}
+   * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/replaceoptions.html#writeconcern}
    */
-  async replace(collectionName, query, replace, options) {
+  async replace(collectionName, query, replace, { writeConcern, session } = {}) {
     const collection = await this.collection(collectionName);
     query = deserialize(query);
     replace = deserialize(replace);
     debug(`db.${collection.collectionName}.replaceOne`, query, replace);
-    let replaceOpts;
-    if (options?.writeConcern) {
-      replaceOpts = { writeConcern: options.writeConcern };
-    }
-    const r = await collection.replaceOne(query, replace, replaceOpts);
+    const r = await collection.replaceOne(query, replace, {
+      writeConcern,
+      session: session?.mongoSession || session
+    });
     r.ops = replace;
     return normalizeResult(r);
   }
 
-
 }
 
 module.exports = new Database();

package/lib/defined-object.js

@@ -1,54 +1,55 @@
-var Immutable = require('./immutable');
+const Immutable = require('./immutable');
 
 /**
- * Immutable handler used to create an immutable object based on definition 
+ * Immutable handler used to create an immutable object based on definition
  * describing the object properties and methods.
  * @name ImmutableDefinedObject
- * @param {object} data 
- * @param {object} builder 
- * @param {object} options
- * @param {object} options.definition
+ * @param {object} data - Underlying defined object
+ * @param {object} builder - Builder instance
+ * @param {object} options - Optional settings
+ * @param {object} options.definition - Defintion settings
  * @param {object} [options.definition.properties] - Describes the properties of the immutable object.
  * @param {object} [options.definition.virtuals] - Describes the virtual properties of the immutable object.
  * @param {object} [options.definition.methods] - Describes the methods of the immutable object.
+ * @returns {undefined} no return value
  */
-module.exports = function (data, builder, options) {
+module.exports = function(data, builder, options) {
 
   if (options.definition) {
-    var definition = options.definition;
+    const definition = options.definition;
     if (definition.name) {
       builder.type = definition.name;
     }
 
     if (definition.properties) {
-      Object.keys(definition.properties).forEach(function (prop) {
-        var propertyDef = definition.properties[prop];
-        var defaultVal = propertyDef.default;
+      Object.keys(definition.properties).forEach(function(prop) {
+        const propertyDef = definition.properties[prop];
+        const defaultVal = propertyDef.default;
         if ('undefined' === typeof data[prop] && 'undefined' !== typeof defaultVal) {
           data[prop] = 'function' === typeof defaultVal ? defaultVal.apply(data) : defaultVal;
         }
-        var value = data[prop];
-        var getter = function () {
+        let value = data[prop];
+        const getter = function() {
           return (value = Immutable.create(value, { definition: propertyDef, clone: false }));
         };
-        var options = {};
+        const getterOptions = {};
         if (propertyDef && 'undefined' !== typeof propertyDef.enumerable) {
-          options.enumerable = propertyDef.enumerable;
+          getterOptions.enumerable = propertyDef.enumerable;
         }
-        builder.defineProperty(prop, getter, options);
+        builder.defineProperty(prop, getter, getterOptions);
       });
     }
     if (definition.virtuals) {
-      Object.keys(definition.virtuals).forEach(function (virtual) {
-        var virtualFunc = definition.virtuals[virtual];
-        builder.defineProperty(virtual, function () {
+      Object.keys(definition.virtuals).forEach(function(virtual) {
+        const virtualFunc = definition.virtuals[virtual];
+        builder.defineProperty(virtual, function() {
           return Immutable.create(virtualFunc.call(data));
         });
       });
     }
     if (definition.methods) {
-      Object.keys(definition.methods).forEach(function (method) {
-        var methodFunc = definition.methods[method];
+      Object.keys(definition.methods).forEach(function(method) {
+        const methodFunc = definition.methods[method];
         builder.defineMethod(method, methodFunc);
       });
     }

package/lib/immutable.js

@@ -1,24 +1,47 @@
-var defaults = require('defaults');
-var assign = require('object-assign');
-var clone = require('clone');
+const clone = require('clone');
 
-var IMMUTABLE_TYPES = [ 'function', 'string', 'boolean', 'number', 'undefined' ];
+const IMMUTABLE_TYPES = [ 'function', 'string', 'boolean', 'number', 'undefined' ];
 
-var typeHandlers = [];
+const typeHandlers = [];
+
+let Immutable;
+const Builder = function(type, props) {
+  this.type = type || 'object';
+  this.props = props || {};
+
+  this.defineProperty = function(name, getterOrValue, options = {}) {
+    options = { enumerable: true, ...options };
+    options.get = ('function' === typeof getterOrValue) ?
+      getterOrValue : function() { return Immutable.create(getterOrValue); };
+    options.set = function() {
+      throw new Error(`Cannot modify ${name} of immutable ${this.type}`);
+    };
+    this.props[name] = options;
+  };
+
+  this.defineMethod = function(name, func, options = {}) {
+    this.props[name] = {
+      enumerable: false,
+      ...options,
+      value: func
+    };
+  };
+};
 
 /**
  * Static class for working with immutable data types.
  * @static Immutable
  */
-var Immutable = {
+Immutable = {
 
   /**
-   * Registers an immutable handler for the given data type. Handlers are used 
+   * Registers an immutable handler for the given data type. Handlers are used
    * to wrap specific data types. For example BSON ObjectIds or Dates.
-   * @param {string} [type=*]
-   * @param {function} handler
+   * @param {string} [type=*] - the name of the type
+   * @param {function} handler - the handler for the type
+   * @returns {undefined} - no return value
    */
-  use: function (type, handler) {
+  use: function(type, handler) {
     if (!handler) {
       handler = type;
       type = '*';
@@ -31,21 +54,21 @@ var Immutable = {
 
   /**
    * Returns `true` if the given value is an Immutable.
-   * @param {object} value
-   * @returns {boolean}
+   * @param {object} value - a value to check
+   * @returns {boolean} - if it is an immutable instance
    */
-  isImmutable: function (value) {
+  isImmutable: function(value) {
     if ('undefined' === typeof value || value === null) { return true; }
     return (IMMUTABLE_TYPES.indexOf(typeof value) > -1 || !!value.__immutable);
   },
 
   /**
    * Returns `true` if the given value is an Immutable of the given type.
-   * @param {object} value
-   * @param {string} type
-   * @returns {boolean}
+   * @param {object} value - a value to check
+   * @param {string} type - type to check against
+   * @returns {boolean} - if the value is an immutable instance of that type
    */
-  isImmutableType: function (value, type) {
+  isImmutableType: function(value, type) {
     return value && value.__immutable && value.__type.toLowerCase() === type.toLowerCase();
   },
 
@@ -53,36 +76,33 @@ var Immutable = {
    * Creates an immutable object based on the given data.
    * @param {object} data - Object to make immutable.
    * @param {object} [options] - Options passed to the immutable handler for the given data type.
-   * @return {object}
+   * @return {object} - the immutable wrapped object
    */
-  create: function (data, options) {
+  create: function(data, options = {}) {
     if (Immutable.isImmutable(data)) {
       return data;
     }
 
-    options = defaults(options, {
-      clone: true
-    });
+    options = { clone: true, ...options };
 
     if (options.clone) {
       data = clone(data);
     }
 
-    var builder = new Builder('object', {});
+    const builder = new Builder('object', {});
     builder.defineProperty('__immutable', true, { enumerable: false });
 
-    builder.defineMethod('toObject', function () {
+    builder.defineMethod('toObject', function() {
       return data;
     });
 
-    builder.defineMethod('mutate', function (cb) {
-      var obj = clone(data);
-      var newOptions = assign({}, options, { clone: false });
+    builder.defineMethod('mutate', function(cb) {
+      const obj = clone(data);
       cb.apply(obj);
-      return Immutable.create(obj, newOptions);
+      return Immutable.create(obj, { ...options, clone: false });
     });
 
-    typeHandlers.forEach(function (typeHandler) {
+    typeHandlers.forEach(function(typeHandler) {
       if ('string' === typeof typeHandler.type) {
         if (typeHandler.type === '*' || typeof data === typeHandler.type) {
           return typeHandler.handler(data, builder, options);
@@ -102,31 +122,7 @@ var Immutable = {
     return Object.freeze(
       Object.create(Object.prototype, builder.props)
     );
-
   }
-
 };
 
 module.exports = Immutable;
-
-var Builder = function (type, props) {
-  this.type = type || 'object';
-  this.props = props || {};
-
-  this.defineProperty = function (name, getterOrValue, options) {
-    options = defaults(options, { enumerable: true });
-    options.get = ('function' === typeof getterOrValue) ?
-      getterOrValue : function () { return Immutable.create(getterOrValue); };
-    options.set = function () {
-      throw new Error('Cannot modify ' + name + ' of immutable ' + this.type);
-    };
-    this.props[name] = options;
-  };
-
-  this.defineMethod = function (name, func, options) {
-    options = defaults(options, { enumerable: false });
-    options.value = func;
-    this.props[name] = options;
-  };
-
-};

package/lib/model.js

@@ -1,9 +1,7 @@
-const assign = require('object-assign');
 const joi = require('@hapi/joi');
 const etag = require('etag');
 const debug = require('debug')('cosa:model');
 const objectPath = require('object-path');
-const defaults = require('defaults');
 const clone = require('clone');
 const { EJSON } = require('bson');
 const Cursor = require('./cursor');
@@ -20,14 +18,6 @@ Immutable.use(require('./object'));
 
 const isNotVirtual = complement(pathEq([ 'type' ], 'virtual'));
 const removeMeta = omit(['__modified', '__original']);
-const onlyJoiOptions = pick(['abortEarly', 'convert', 'allowUnknown', 'skipFunctions', 'stripUnknown']);
-const defaultJoiOptions = {
-  abortEarly: false,
-  convert: false,
-  allowUnknown: false,
-  skipFunctions: true,
-  stripUnknown: false
-};
 
 const db = require('./db');
 // functions that are defined later on.
@@ -118,7 +108,6 @@ const _create = (data, definition) => {
   };
 
   const _saveHelper = async function(context, options = {}, explicitId) {
-    options = defaults(options, { waitAfterSave: false });
     if (!context.isNew() && !context.isModified()) {
       return context;
     }
@@ -127,7 +116,7 @@ const _create = (data, definition) => {
       await context.beforeSave.apply(obj, [options]);
     }
     obj = await context._validate(obj, options);
-    const original = obj.__original;
+    const original = obj.__original || null;
     obj = removeMeta(obj);
     const newEtag = etag(JSON.stringify(obj));
     const collection = definition.collection;
@@ -170,10 +159,27 @@ const _create = (data, definition) => {
       obj = Array.isArray(result.ops) ? result.ops[0] : result.ops;
       newOrUpdatedModel = _create(obj, definition);
     }
-    if ('function' === typeof newOrUpdatedModel.afterSave) {
-      // should not be awaited
-      const afterSave = newOrUpdatedModel.afterSave(original || null, options);
-      if (options.waitAfterSave) { await afterSave; }
+    if (options.session) {
+      if ('function' === typeof newOrUpdatedModel.afterSave) {
+        await newOrUpdatedModel.afterSave(original, options);
+      }
+      if ('function' === typeof newOrUpdatedModel.afterSaveCommit) {
+        options.session.afterCommits.push(() => newOrUpdatedModel.afterSaveCommit(original, options));
+      }
+      if ('function' === typeof newOrUpdatedModel.afterSaveAbort) {
+        options.session.afterAborts.push(() => newOrUpdatedModel.afterSaveAbort(original, options));
+      }
+    } else {
+      let chain = Promise.resolve();
+      if ('function' === typeof newOrUpdatedModel.afterSave) {
+        chain = chain.then(() => newOrUpdatedModel.afterSave(original, options));
+      }
+      if ('function' === typeof newOrUpdatedModel.afterSaveCommit) {
+        chain = chain.then(() => newOrUpdatedModel.afterSaveCommit(original, options));
+      }
+      if (options.waitAfterSave) {
+        await chain;
+      }
     }
     return newOrUpdatedModel;
   };
@@ -213,16 +219,15 @@ const _create = (data, definition) => {
     return this.mutate(function() {
       let paths;
       if ('object' === typeof pathOrObj && !Array.isArray(pathOrObj)) {
-        options = defaults(value, { silent: false });
-        assign(this, pathOrObj);
+        options = value;
+        Object.assign(this, pathOrObj);
         paths = Object.keys(pathOrObj);
       } else {
-        options = defaults(options, { silent: false });
         objectPath.set(this, pathOrObj, value);
         paths = [pathOrObj];
       }
 
-      if (!options.silent) {
+      if (!options?.silent) {
         _markAsModified(this, paths, original);
       }
     });
@@ -240,35 +245,24 @@ const _create = (data, definition) => {
     return objectPath.has(this, path);
   };
 
-  definition.methods.toJSON = function(options) {
-    // can only have include or exclude not both, should there be an error thrown if both are given?
-    // probably not
-    options = defaults(options, {
-      virtuals: true,
-      extended: true,
-      exclude: undefined, // array of properties to exclude from the json object
-      include: undefined, // array of white listed properties to include in the json object
-      transform: undefined // function that accepts json object and returns a transformed version
-    });
-    // TODO move this out of here, there are no references to this, it's just mutation...recursive
-
+  definition.methods.toJSON = function({ virtuals = true, extended = true, exclude, include, transform } = {}) {
     let json = removeMeta(this.toObject());
     json = clone(json); // not 100% sure we need to clone
 
-    if (options.virtuals) {
+    if (virtuals) {
       addVirtuals(definition, json);
     }
-    if (options.extended) {
+    if (extended) {
       json = EJSON.serialize(json);
     }
     json = _serialize(json);
-    if (options.exclude) {
-      json = omit(options.exclude, json);
-    } else if (options.include) {
-      json = pick(options.include, json);
+    if (exclude) {
+      json = omit(exclude, json);
+    } else if (include) {
+      json = pick(include, json);
     }
-    if (options.transform) {
-      json = options.transform.call(null, json);
+    if (transform) {
+      json = transform(json);
     }
     return json;
   };
@@ -277,10 +271,21 @@ const _create = (data, definition) => {
     return this._validate(this.toObject(), options);
   };
 
-  definition.methods._validate = async function(obj, options = {}) {
-    const joiOptions = defaults(onlyJoiOptions(options), defaultJoiOptions);
+  definition.methods._validate = async function(obj, {
+    abortEarly = false,
+    convert = false,
+    allowUnknown = false,
+    skipFunctions = true,
+    stripUnknown = false
+  } = {} ) {
     try {
-      return await definition._schema.validateAsync(obj, joiOptions);
+      return await definition._schema.validateAsync(obj, {
+        abortEarly,
+        convert,
+        allowUnknown,
+        skipFunctions,
+        stripUnknown
+      });
     } catch (err) {
       throw errors.Validation(err);
     }
@@ -297,8 +302,7 @@ const _create = (data, definition) => {
     return _saveHelper(this, options, new ObjectId(id));
   };
 
-  definition.methods.remove = async function(options) {
-    options = defaults(options, { waitAfterRemove: false });
+  definition.methods.remove = async function(options = {}) {
     const collection = definition.collection;
     const query = { _id: this._id, _etag: this._etag };
     if ('function' === typeof this.beforeRemove) {
@@ -310,10 +314,30 @@ const _create = (data, definition) => {
       throw errors.Conflict({ message: 'Document remove conflict' });
     }
     debug(`remove from ${collection} successful`);
-    if ('function' === typeof this.afterRemove) {
-      const afterRemove = this.afterRemove(options);
-      if (options.waitAfterRemove) { await afterRemove; }
+
+    if (options.session) {
+      if ('function' === typeof this.afterRemove) {
+        await this.afterRemove(options);
+      }
+      if ('function' === typeof this.afterRemoveCommit) {
+        options.session.afterCommits.push(() => this.afterRemoveCommit(options));
+      }
+      if ('function' === typeof this.afterRemoveAbort) {
+        options.session.afterAborts.push(() => this.afterRemoveAbort(options));
+      }
+    } else {
+      let chain = Promise.resolve();
+      if ('function' === typeof this.afterRemove) {
+        chain = chain.then(() => this.afterRemove(options));
+      }
+      if ('function' === typeof this.afterRemoveCommit) {
+        chain = chain.then(() => this.afterRemoveCommit(options));
+      }
+      if (options.waitAfterRemove) {
+        await chain;
+      }
     }
+
     return result;
   };
 
@@ -342,11 +366,12 @@ const _create = (data, definition) => {
   */
 const define = (definition) => {
 
-  definition = defaults(definition, {
+  definition = {
     properties: {},
     methods: {},
-    virtuals: {}
-  });
+    virtuals: {},
+    ...definition
+  };
 
   if (!definition.collection && !definition.abstract) {
     throw new Error('A model must have a collection unless defined as abstract');
@@ -376,7 +401,7 @@ const define = (definition) => {
 
   const applyGlobalWhere = (query, options) => {
     return options.bypassGlobalWhere || !definition.where ?
-      query : assign({}, definition.where, query);
+      query : { ...definition.where, ...(query || {}) };
   };
 
   return {
@@ -398,11 +423,10 @@ const define = (definition) => {
     },
 
     count: (query, options = {}) => {
-      options = assign({}, options, { count: true });
       query = applyGlobalWhere(query, options);
       const collection = definition.collection;
       debug(`counting ${JSON.stringify(query)} in ${collection}`);
-      return db.find(collection, query, options);
+      return db.find(collection, query, { ...options, count: true });
     },
 
     find: async (query, options = {}) => {
@@ -417,19 +441,17 @@ const define = (definition) => {
     },
 
     findOne: async (query, options = {}) => {
-      options = assign({}, options, { findOne: true });
       query = applyGlobalWhere(query, options);
       const collection = definition.collection;
       debug(`finding one${JSON.stringify(query)} in ${collection}`);
-      const result = await db.find(collection, query, options);
+      const result = await db.find(collection, query, { ...options, findOne: true });
       return !result ? null : _create(result, definition);
     },
 
-    update: (query, update, options = {}) => {
-      options = defaults(options, { autoSet: true });
+    update: (query, update, { autoSet = true, ...options } = {}) => {
       query = applyGlobalWhere(query, options);
       const collection = definition.collection;
-      if (options.autoSet) {
+      if (autoSet) {
         update = { $set: update };
       }
       debug(`updating ${JSON.stringify(query)} from ${collection}`);
@@ -474,9 +496,9 @@ _extend = (definition, superDef) => {
   if (!newDef.collection) {
     newDef.collection = superDef.collection;
   }
-  newDef.properties = defaults(newDef.properties, superDef.properties || {});
-  newDef.methods = defaults(newDef.methods, superDef.methods || {});
-  newDef.virtuals = defaults(newDef.virtuals, superDef.virtuals || {});
+  newDef.properties = { ...(superDef.properties || {}), ...(newDef.properties || {}) };
+  newDef.methods = { ...(superDef.methods || {}), ...(newDef.methods || {}) };
+  newDef.virtuals = { ...(superDef.virtuals || {}), ...(newDef.virtuals || {}) };
   return define(newDef);
 };
 

package/lib/object.js

@@ -4,20 +4,23 @@ const addProp = function(name, builder, data) {
   if (builder.props[name]) { return; }
   let value = data[name];
   if ('function' === typeof value) { return; }
-  const getter = function () {
+  const getter = function() {
     return (value = Immutable.create(value, { clone: false }));
   };
   builder.defineProperty(name, getter);
-}
+};
 
 /**
  * Immutable handler used to wrap a simple javascript object.
  * @name ImmutableObject
- * @param {object} data 
- * @param {object} builder 
+ * @param {object} data - Underlying array
+ * @param {object} builder - Builder instance
+ * @returns {undefined} no return value
  */
-module.exports = function (data, builder) {
-  for (let p in data) {
-    addProp(p, builder, data);
+module.exports = function(data, builder) {
+  for (const p in data) {
+    if (Object.prototype.hasOwnProperty.call(data, p)) {
+      addProp(p, builder, data);
+    }
   }
 };

package/lib/session.js

@@ -0,0 +1,58 @@
+const db = require('./db');
+const { forEachSerialP } = require('omnibelt');
+
+const createSession = async () => {
+  const afterCommits = [];
+  const afterAborts = [];
+  if (!db._client) {
+    await db.init();
+  }
+  const session = await db._client.startSession();
+
+  const abortTransaction = async () => {
+    let error;
+    await session.abortTransaction();
+    await session.endSession();
+    await forEachSerialP(async (afterAborted) => {
+      try {
+        await afterAborted(error);
+      } catch (err) {
+        if (!err) {
+          error = err;
+        }
+      }
+    }, afterAborts);
+    if (error) { throw error; }
+  };
+
+  return {
+    get mongoSession() {
+      return session;
+    },
+    startTransaction: () => {
+      return session.startTransaction();
+    },
+    commitTransaction: async () => {
+      let error;
+      await session.commitTransaction();
+      await session.endSession();
+      await forEachSerialP(async (afterCommitFunc) => {
+        try {
+          await afterCommitFunc();
+        } catch (err) {
+          if (!error) {
+            error = err;
+          }
+        }
+      }, afterCommits);
+      if (error) { throw error; }
+    },
+    abortTransaction,
+    afterCommits,
+    afterAborts
+  };
+};
+
+module.exports = {
+  createSession
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cosa",
-  "version": "6.0.0",
+  "version": "6.2.0",
   "description": "Cosa Models for MongoDB",
   "main": "lib/index.js",
   "engines": {
@@ -35,39 +35,30 @@
     "lib"
   ],
   "dependencies": {
-    "bson": "~4.5.1",
+    "bson": "~4.6.4",
     "clone": "^2.1.2",
-    "debug": "^4.3.2",
-    "defaults": "^1.0.3",
+    "debug": "^4.3.4",
     "error": "^7.0.2",
     "etag": "^1.8.1",
     "@hapi/joi": "^17.1.1",
-    "mongodb": "~4.1.1",
-    "object-assign": "^4.1.1",
-    "object-path": "^0.11.7",
+    "mongodb": "~4.7.0",
+    "object-path": "^0.11.8",
     "omnibelt": "^2.1.0"
   },
   "devDependencies": {
     "@losant/eslint-config-losant": "^1.4.3",
-    "husky": "^7.0.2",
-    "lint-staged": "^11.1.2",
-    "chai": "^4.3.4",
+    "husky": "^8.0.1",
+    "lint-staged": "^13.0.2",
+    "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "chai-datetime": "^1.8.0",
     "documentation": "^13.2.5",
-    "mocha": "^9.1.1",
+    "mocha": "^10.0.0",
     "string-template": "^1.0.0"
   },
   "eslintConfig": {
     "extends": "@losant/eslint-config-losant/env/node"
   },
-  "eslintIgnore": [
-    "lib/array.js",
-    "lib/date.js",
-    "lib/defined-object.js",
-    "lib/immutable.js",
-    "lib/object.js"
-  ],
   "mocha": {
     "require": "chai",
     "reporter": "spec",