mongoose 7.8.1 → 7.8.2

package/lib/cast.js

@@ -65,10 +65,11 @@ module.exports = function cast(schema, obj, options, context) {
       if (!Array.isArray(val)) {
         throw new CastError('Array', val, path);
       }
-      for (let k = 0; k < val.length; ++k) {
+      for (let k = val.length - 1; k >= 0; k--) {
         if (val[k] == null || typeof val[k] !== 'object') {
           throw new CastError('Object', val[k], path + '.' + k);
         }
+        const beforeCastKeysLength = Object.keys(val[k]).length;
         const discriminatorValue = val[k][schema.options.discriminatorKey];
         if (discriminatorValue == null) {
           val[k] = cast(schema, val[k], options, context);
@@ -76,6 +77,15 @@ module.exports = function cast(schema, obj, options, context) {
           const discriminatorSchema = getSchemaDiscriminatorByValue(context.schema, discriminatorValue);
           val[k] = cast(discriminatorSchema ? discriminatorSchema : schema, val[k], options, context);
         }
+
+        if (Object.keys(val[k]).length === 0 && beforeCastKeysLength !== 0) {
+          val.splice(k, 1);
+        }
+      }
+
+      // delete empty: {$or: []} -> {}
+      if (val.length === 0) {
+        delete obj[path];
       }
     } else if (path === '$where') {
       type = typeof val;

package/lib/document.js

@@ -1204,7 +1204,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
         this.$__setValue(path, null);
         cleanModifiedSubpaths(this, path);
       } else {
-        return this.$set(val, path, constructing);
+        return this.$set(val, path, constructing, options);
       }
 
       const keys = getKeysInSchemaOrder(this.$__schema, val, path);

package/lib/helpers/projection/isExclusive.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const isDefiningProjection = require('./isDefiningProjection');
+const isPOJO = require('../isPOJO');
 
 /*!
  * ignore
@@ -22,10 +23,12 @@ module.exports = function isExclusive(projection) {
       // Explicitly avoid `$meta` and `$slice`
       const key = keys[ki];
       if (key !== '_id' && isDefiningProjection(projection[key])) {
-        exclude = (projection[key] != null && typeof projection[key] === 'object') ?
-          isExclusive(projection[key]) :
+        exclude = isPOJO(projection[key]) ?
+          (isExclusive(projection[key]) ?? exclude) :
           !projection[key];
-        break;
+        if (exclude != null) {
+          break;
+        }
       }
     }
   }

package/lib/helpers/projection/isInclusive.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const isDefiningProjection = require('./isDefiningProjection');
+const isPOJO = require('../isPOJO');
 
 /*!
  * ignore
@@ -26,7 +27,7 @@ module.exports = function isInclusive(projection) {
     // If field is truthy (1, true, etc.) and not an object, then this
     // projection must be inclusive. If object, assume its $meta, $slice, etc.
     if (isDefiningProjection(projection[prop]) && !!projection[prop]) {
-      if (projection[prop] != null && typeof projection[prop] === 'object') {
+      if (isPOJO(projection[prop])) {
         return isInclusive(projection[prop]);
       } else {
         return !!projection[prop];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "7.8.1",
+  "version": "7.8.2",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/sample.md

@@ -1,133 +0,0 @@
-# Transactions in Mongoose
-
-[Transactions](https://www.mongodb.com/transactions) let you execute multiple operations in isolation and potentially undo all the operations if one of them fails.
-This guide will get you started using transactions with Mongoose.
-
-## Getting Started with Transactions {#getting-started-with-transactions}
-
-If you haven't already, import mongoose:
-
-```javascript
-import mongoose from 'mongoose';
-```
-
-To create a transaction, you first need to create a session using [`Mongoose#startSession`](api/mongoose.html#mongoose_Mongoose-startSession)
-or [`Connection#startSession()`](api/connection.html#connection_Connection-startSession).
-
-```javascript
-// Using Mongoose's default connection
-const session = await mongoose.startSession();
-
-// Using custom connection
-const db = await mongoose.createConnection(mongodbUri).asPromise();
-const session = await db.startSession();
-```
-
-In practice, you should use either the [`session.withTransaction()` helper](https://mongodb.github.io/node-mongodb-native/3.2/api/ClientSession.html#withTransaction)
-or Mongoose's `Connection#transaction()` function to run a transaction. The `session.withTransaction()` helper handles:
-
-* Creating a transaction
-* Committing the transaction if it succeeds
-* Aborting the transaction if your operation throws
-* Retrying in the event of a [transient transaction error](https://stackoverflow.com/questions/52153538/what-is-a-transienttransactionerror-in-mongoose-or-mongodb).
-
-```acquit
-[require:transactions.*withTransaction]
-```
-
-For more information on the `ClientSession#withTransaction()` function, please see
-[the MongoDB Node.js driver docs](https://mongodb.github.io/node-mongodb-native/3.2/api/ClientSession.html#withTransaction).
-
-Mongoose's `Connection#transaction()` function is a wrapper around `withTransaction()` that
-integrates Mongoose change tracking with transactions.
-For example, suppose you `save()` a document in a transaction that later fails.
-The changes in that document are not persisted to MongoDB.
-The `Connection#transaction()` function informs Mongoose change tracking that the `save()` was rolled back, and marks all fields that were changed in the transaction as modified.
-
-```javascript
-const doc = new Person({ name: 'Will Riker' });
-
-await db.transaction(async function setRank(session) {
-  doc.name = 'Captain';
-  await doc.save({ session });
-  doc.isNew; // false
-
-  // Throw an error to abort the transaction
-  throw new Error('Oops!');
-}, { readPreference: 'primary' }).catch(() => {});
-
-// true, `transaction()` reset the document's state because the
-// transaction was aborted.
-doc.isNew;
-```
-
-## Note About Parallelism in Transactions {#note-about-parallelism-in-transactions}
-
-Running operations in parallel is **not supported** during a transaction. The use of `Promise.all`, `Promise.allSettled`, `Promise.race`, etc. to parallelize operations inside a transaction is
-undefined behaviour and should be avoided.
-
-## With Mongoose Documents and `save()` {#with-mongoose-documents-and-save}
-
-If you get a [Mongoose document](documents.html) from [`findOne()`](api/model.html#model_Model-findOne)
-or [`find()`](api/model.html#model_Model-find) using a session, the document will
-keep a reference to the session and use that session for [`save()`](api/document.html#document_Document-save).
-
-To get/set the session associated with a given document, use [`doc.$session()`](api/document.html#document_Document-$session).
-
-```acquit
-[require:transactions.*save]
-```
-
-## With the Aggregation Framework {#with-the-aggregation-framework}
-
-The `Model.aggregate()` function also supports transactions. Mongoose
-aggregations have a [`session()` helper](api/aggregate.html#aggregate_Aggregate-session)
-that sets the [`session` option](api/aggregate.html#aggregate_Aggregate-option).
-Below is an example of executing an aggregation within a transaction.
-
-```acquit
-[require:transactions.*aggregate]
-```
-
-## Using AsyncLocalStorage {#asynclocalstorage}
-
-One major pain point with transactions in Mongoose is that you need to remember to set the `session` option on every operation.
-If you don't, your operation will execute outside of the transaction.
-Mongoose 8.4 is able to set the `session` operation on all operations within a `Connection.prototype.transaction()` executor function using Node's [AsyncLocalStorage API](https://nodejs.org/api/async_context.html#class-asynclocalstorage).
-Set the `transactionAsyncLocalStorage` option using `mongoose.set('transactionAsyncLocalStorage', true)` to enable this feature.
-
-```javascript
-mongoose.set('transactionAsyncLocalStorage', true);
-
-const Test = mongoose.model('Test', mongoose.Schema({ name: String }));
-
-const doc = new Test({ name: 'test' });
-
-// Save a new doc in a transaction that aborts
-await connection.transaction(async() => {
-  await doc.save(); // Notice no session here
-  throw new Error('Oops');
-}).catch(() => {});
-
-// false, `save()` was rolled back
-await Test.exists({ _id: doc._id });
-```
-
-With `transactionAsyncLocalStorage`, you no longer need to pass sessions to every operation.
-Mongoose will add the session by default under the hood.
-
-## Advanced Usage {#advanced-usage}
-
-Advanced users who want more fine-grained control over when they commit or abort transactions
-can use `session.startTransaction()` to start a transaction:
-
-```acquit
-[require:transactions.*basic example]
-```
-
-You can also use `session.abortTransaction()` to abort a transaction:
-
-```acquit
-[require:transactions.*abort]
-```
-

package/test.js

@@ -1,43 +0,0 @@
-const cheerio = require('cheerio');
-
-const handle = (line) => {
-  if (line.startsWith('<h2') && line.includes('</h2')) {
-    const $ = cheerio.load(line);
-    const h2 = $('h2');
-
-    let textContainer = h2;
-    const first = h2.children().first()[0];
-    if (first?.type === 'tag' && first?.name === 'a') {
-      textContainer = $(first);
-    }
-
-    // contents() not children(), because contents() also returns text nodes
-    const children = [...textContainer.contents()];
-    const text = children.map(el => el.type === 'tag' && el.name === 'code' ? '`' + $(el).text() + '`' : $(el).text()).join('');
-    return `## ${text}` + (h2.attr('id') ? ` {#${h2.attr('id')}}` : '');
-  }
-  if (line.startsWith('<h3') && line.includes('</h3')) {
-    const $ = cheerio.load(line);
-    const h3 = $('h3');
-
-    let textContainer = h3;
-    const first = h3.children().first()[0];
-    if (first?.type === 'tag' && first?.name === 'a') {
-      textContainer = $(first);
-    }
-
-    // contents() not children(), because contents() also returns text nodes
-    const children = [...textContainer.contents()];
-    const text = children.map(el => el.type === 'tag' && el.name === 'code' ? '`' + $(el).text() + '`' : $(el).text()).join('');
-
-    return `### ${text}` + (h3.attr('id') ? ` {#${h3.attr('id')}}` : '');
-  }
-
-  return line;
-};
-
-const str = require('fs').readFileSync(process.argv[2]).toString('utf8');
-
-const lines = str.split('\n');
-
-console.log(lines.map(line => handle(line)).join('\n'));