@depup/mongoose 9.3.3-depup.0 → 9.8.0-depup.0

package/README.md

@@ -13,16 +13,10 @@ npm install @depup/mongoose
 
 | Field | Value |
 |-------|-------|
-| Original | [mongoose](https://www.npmjs.com/package/mongoose) @ 9.3.3 |
-| Processed | 2026-03-25 |
+| Original | [mongoose](https://www.npmjs.com/package/mongoose) @ 9.8.0 |
+| Processed | 2026-07-21 |
 | Smoke test | passed |
-| Deps updated | 1 |
-
-## Dependency Changes
-
-| Dependency | From | To |
-|------------|------|-----|
-| mongodb | ~7.1 | ^7.1.1 |
+| Deps updated | 0 |
 
 ---
 

package/changes.json

@@ -1,10 +1,5 @@
 {
-  "bumped": {
-    "mongodb": {
-      "from": "~7.1",
-      "to": "^7.1.1"
-    }
-  },
-  "timestamp": "2026-03-25T20:16:19.527Z",
-  "totalUpdated": 1
+  "bumped": {},
+  "timestamp": "2026-07-21T16:17:39.127Z",
+  "totalUpdated": 0
 }

package/eslint.config.mjs

@@ -15,7 +15,10 @@ export default defineConfig([
     '!**/.*',
     '**/node_modules',
     '**/.git',
-    '**/data'
+    '**/data',
+    '**/docs/3.*/**',
+    '**/docs/5.*/**',
+    '**/docs/vendor/*'
   ]),
   js.configs.recommended,
   // general options

package/lib/aggregate.js

@@ -15,6 +15,8 @@ const { buildMiddlewareFilter } = require('./helpers/buildMiddlewareFilter');
 const stringifyFunctionOperators = require('./helpers/aggregate/stringifyFunctionOperators');
 const utils = require('./utils');
 const { modelSymbol } = require('./helpers/symbols');
+const { createTracedChannel } = require('./tracing');
+const { trace: traceAggregate } = createTracedChannel('mongoose:aggregate');
 const read = Query.prototype.read;
 const readConcern = Query.prototype.readConcern;
 
@@ -613,6 +615,9 @@ Aggregate.prototype.graphLookup = function(options) {
  *
  *     aggregate.sample(3); // Add a pipeline that picks 3 random documents
  *
+ *     // `$match` before `$sample` samples from the filtered subset
+ *     aggregate.match({ difficulty: 'easy' }).sample(3);
+ *
  * @see $sample https://www.mongodb.com/docs/manual/reference/operator/aggregation/sample/#pipe._S_sample
  * @param {number} size number of random documents to pick
  * @return {Aggregate}
@@ -1032,7 +1037,7 @@ Aggregate.prototype.pipeline = function() {
  *     const base = MyModel.aggregate().match({ test: 1 });
  *     base.pipelineForUnionWith(); // [{ $match: { test: 1 } }]
  *
- * @return {Array} The current pipeline with `$unionWith` stage restrictions
+ * @return {PipelineStage[]} The current pipeline with `$unionWith` stage restrictions
  * @api public
  */
 
@@ -1071,8 +1076,20 @@ Aggregate.prototype.exec = async function exec() {
 
     this._optionsForExec();
 
-    const cursor = await this._connection.client.db().aggregate(this._pipeline, this.options);
-    return await cursor.toArray();
+    const _this = this;
+    return traceAggregate(async function maybeTracedConnectionAggregate() {
+      const cursor = await _this._connection.client.db().aggregate(_this._pipeline, _this.options);
+      return await cursor.toArray();
+    }, () => ({
+      operation: 'aggregate',
+      database: _this._connection.name,
+      serverAddress: _this._connection.host,
+      serverPort: _this._connection.port,
+      args: {
+        pipeline: _this._pipeline,
+        options: _this.options
+      }
+    }));
   }
 
   const model = this._model;
@@ -1090,32 +1107,45 @@ Aggregate.prototype.exec = async function exec() {
   prepareDiscriminatorPipeline(this._pipeline, this._model.schema);
   stringifyFunctionOperators(this._pipeline);
 
-  const preFilter = buildMiddlewareFilter(this.options, 'pre');
-  const postFilter = buildMiddlewareFilter(this.options, 'post');
+  const _this = this;
+  return traceAggregate(async function maybeTracedAggregateExec() {
+    const preFilter = buildMiddlewareFilter(_this.options, 'pre');
+    const postFilter = buildMiddlewareFilter(_this.options, 'post');
 
-  try {
-    await model.hooks.execPre('aggregate', this, [], { filter: preFilter });
-  } catch (error) {
-    return await model.hooks.execPost('aggregate', this, [null], { error, filter: postFilter });
-  }
+    try {
+      await model.hooks.execPre('aggregate', _this, [], { filter: preFilter });
+    } catch (error) {
+      return await model.hooks.execPost('aggregate', _this, [null], { error, filter: postFilter });
+    }
 
-  if (!this._pipeline.length) {
-    throw new MongooseError('Aggregate has empty pipeline');
-  }
+    if (!_this._pipeline.length) {
+      throw new MongooseError('Aggregate has empty pipeline');
+    }
 
-  const options = clone(this.options || {});
-  delete options.middleware;
+    const options = clone(_this.options || {});
+    delete options.middleware;
 
-  let result;
-  try {
-    const cursor = await collection.aggregate(this._pipeline, options);
-    result = await cursor.toArray();
-  } catch (error) {
-    return await model.hooks.execPost('aggregate', this, [null], { error, filter: postFilter });
-  }
+    let result;
+    try {
+      const cursor = await collection.aggregate(_this._pipeline, options);
+      result = await cursor.toArray();
+    } catch (error) {
+      return await model.hooks.execPost('aggregate', _this, [null], { error, filter: postFilter });
+    }
 
-  await model.hooks.execPost('aggregate', this, [result], { error: null, filter: postFilter });
-  return result;
+    await model.hooks.execPost('aggregate', _this, [result], { error: null, filter: postFilter });
+    return result;
+  }, () => ({
+    operation: 'aggregate',
+    collection: collection.name,
+    database: model.db?.name,
+    serverAddress: model.db?.host,
+    serverPort: model.db?.port,
+    args: {
+      pipeline: _this._pipeline,
+      options: _this.options
+    }
+  }));
 };
 
 /**

package/lib/cast.js

@@ -413,7 +413,7 @@ function _cast(val, numbertype, context) {
         _cast(item, numbertype, context);
         val[nkey] = item;
       } else {
-        val[nkey] = numbertype.castForQuery({ val: item, context: context });
+        val[nkey] = numbertype.castForQuery(null, item, context);
       }
     }
   }

package/lib/connection.js

@@ -1005,10 +1005,7 @@ Connection.prototype.error = function error(err, callback) {
 Connection.prototype.onOpen = function() {
   this.readyState = STATES.connected;
 
-  for (const d of this._queue) {
-    d.fn.apply(d.ctx, d.args);
-  }
-  this._queue = [];
+  this._flushQueue();
 
   // avoid having the collection subscribe to our event emitter
   // to prevent 0.3 warning
@@ -1021,6 +1018,21 @@ Connection.prototype.onOpen = function() {
   this.emit('open');
 };
 
+/**
+ * Flush all buffered operations in `_queue`. Called by `onOpen()` and
+ * by the heartbeat handler when a previously-stale connection recovers.
+ *
+ * @api private
+ */
+
+Connection.prototype._flushQueue = function _flushQueue() {
+  const queue = this._queue;
+  this._queue = [];
+  for (const d of queue) {
+    d.fn.apply(d.ctx, d.args);
+  }
+};
+
 /**
  * Opens the connection with a URI using `MongoClient.connect()`.
  *
@@ -1033,11 +1045,11 @@ Connection.prototype.onOpen = function() {
  * @param {string} [options.pass] password for authentication, equivalent to `options.auth.password`. Maintained for backwards compatibility.
  * @param {number} [options.maxPoolSize=100] The maximum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
  * @param {number} [options.minPoolSize=0] The minimum number of sockets the MongoDB driver will keep open for this connection. Keep in mind that MongoDB only allows one operation per socket at a time, so you may want to increase this if you find you have a few slow queries that are blocking faster queries from proceeding. See [Slow Trains in MongoDB and Node.js](https://thecodebarbarian.com/slow-trains-in-mongodb-and-nodejs).
- * @param {number} [options.serverSelectionTimeoutMS] If `useUnifiedTopology = true`, the MongoDB driver will try to find a server to send any given operation to, and keep retrying for `serverSelectionTimeoutMS` milliseconds before erroring out. If not set, the MongoDB driver defaults to using `30000` (30 seconds).
- * @param {number} [options.heartbeatFrequencyMS] If `useUnifiedTopology = true`, the MongoDB driver sends a heartbeat every `heartbeatFrequencyMS` to check on the status of the connection. A heartbeat is subject to `serverSelectionTimeoutMS`, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a `'disconnected'` event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits `'disconnected'`. We recommend you do **not** set this setting below 1000, too many heartbeats can lead to performance degradation.
+ * @param {number} [options.serverSelectionTimeoutMS] The MongoDB driver will try to find a server to send any given operation to, and keep retrying for `serverSelectionTimeoutMS` milliseconds before erroring out. If not set, the MongoDB driver defaults to using `30000` (30 seconds).
+ * @param {number} [options.heartbeatFrequencyMS] The MongoDB driver sends a heartbeat every `heartbeatFrequencyMS` to check on the status of the connection. A heartbeat is subject to `serverSelectionTimeoutMS`, so the MongoDB driver will retry failed heartbeats for up to 30 seconds by default. Mongoose only emits a `'disconnected'` event after a heartbeat has failed, so you may want to decrease this setting to reduce the time between when your server goes down and when Mongoose emits `'disconnected'`. We recommend you do **not** set this setting below 1000, too many heartbeats can lead to performance degradation.
  * @param {boolean} [options.autoIndex=true] Mongoose-specific option. Set to false to disable automatic index creation for all models associated with this connection.
  * @param {number} [options.socketTimeoutMS=0] How long the MongoDB driver will wait before killing a socket due to inactivity _after initial connection_. A socket may be inactive because of either no activity or a long-running operation. `socketTimeoutMS` defaults to 0, which means Node.js will not time out the socket due to inactivity. This option is passed to [Node.js `socket#setTimeout()` function](https://nodejs.org/api/net.html#net_socket_settimeout_timeout_callback) after the MongoDB driver successfully completes.
- * @param {number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
+ * @param {number} [options.family=0] Passed transparently to [Node.js' `dns.lookup()`](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback) function. May be either `0`, `4`, or `6`. `4` means use IPv4 only, `6` means use IPv6 only, `0` means try both.
  * @param {boolean} [options.autoCreate=false] Set to `true` to make Mongoose automatically call `createCollection()` on every model created on this connection.
  * @returns {Promise<Connection>}
  * @api public
@@ -1342,7 +1354,7 @@ Connection.prototype.onClose = function onClose(force) {
 
 /**
  * Retrieves a raw collection instance, creating it if not cached.
- * This method returns a thin wrapper around a [MongoDB Node.js driver collection]([MongoDB Node.js driver collection](https://mongodb.github.io/node-mongodb-native/Next/classes/Collection.html)).
+ * This method returns a thin wrapper around a [MongoDB Node.js driver collection](https://mongodb.github.io/node-mongodb-native/Next/classes/Collection.html).
  * Using a Collection bypasses Mongoose middleware, validation, and casting,
  * letting you use [MongoDB Node.js driver](https://mongodb.github.io/node-mongodb-native/) functionality directly.
  *

package/lib/cursor/aggregationCursor.js

@@ -10,6 +10,7 @@ const eachAsync = require('../helpers/cursor/eachAsync');
 const immediate = require('../helpers/immediate');
 const kareem = require('kareem');
 const util = require('util');
+const { cursorNextChannel } = require('../tracing');
 
 /**
  * An AggregationCursor is a concurrency primitive for processing aggregation
@@ -62,13 +63,7 @@ util.inherits(AggregationCursor, Readable);
  */
 
 function _init(model, c, agg) {
-  if (!model.collection.buffer) {
-    model.hooks.execPre('aggregate', agg).then(() => onPreComplete(null), err => onPreComplete(err));
-  } else {
-    model.collection.emitter.once('queue', function() {
-      model.hooks.execPre('aggregate', agg).then(() => onPreComplete(null), err => onPreComplete(err));
-    });
-  }
+  model.hooks.execPre('aggregate', agg).then(() => onPreComplete(null), err => onPreComplete(err));
 
   function onPreComplete(err) {
     if (err != null) {
@@ -79,8 +74,28 @@ function _init(model, c, agg) {
       c._transforms.push(agg.options.cursor.transform);
     }
 
-    c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
-    c.emit('cursor', c.cursor);
+    if (model.collection._shouldBufferCommands() && model.collection.buffer) {
+      model.collection.queue.push([
+        () => _getRawCursor(model, c, agg)
+      ]);
+    } else {
+      _getRawCursor(model, c, agg);
+    }
+  }
+}
+
+/*!
+ * ignore
+ */
+
+function _getRawCursor(model, aggregationCursor, agg) {
+  try {
+    const cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
+    aggregationCursor.cursor = cursor;
+    aggregationCursor.emit('cursor', cursor);
+  } catch (err) {
+    aggregationCursor._markError(err);
+    aggregationCursor.listeners('error').length > 0 && aggregationCursor.emit('error', aggregationCursor._error);
   }
 }
 
@@ -277,14 +292,30 @@ AggregationCursor.prototype.next = async function next() {
   if (typeof arguments[0] === 'function') {
     throw new MongooseError('AggregationCursor.prototype.next() no longer accepts a callback');
   }
-  return new Promise((resolve, reject) => {
-    _next(this, (err, res) => {
-      if (err != null) {
-        return reject(err);
-      }
-      resolve(res);
+  const _this = this;
+  const model = this.agg._model;
+  return cursorNextChannel.trace(function maybeTracedAggCursorNext() {
+    return new Promise((resolve, reject) => {
+      _next(_this, (err, res) => {
+        if (err != null) {
+          return reject(err);
+        }
+        resolve(res);
+      });
     });
-  });
+  }, () => ({
+    operation: 'aggregate',
+    collection: model?.collection?.name,
+    database: model?.db?.name,
+    serverAddress: model?.db?.host,
+    serverPort: model?.db?.port,
+    batchSize: _this.agg.options?.cursor?.batchSize,
+    tailable: false,
+    args: {
+      pipeline: _this.agg._pipeline,
+      options: _this.agg.options
+    }
+  }));
 };
 
 /**

package/lib/cursor/queryCursor.js

@@ -12,6 +12,7 @@ const kareem = require('kareem');
 const immediate = require('../helpers/immediate');
 const { once } = require('events');
 const util = require('util');
+const { cursorNextChannel } = require('../tracing');
 
 /**
  * A QueryCursor is a concurrency primitive for processing query results
@@ -310,14 +311,29 @@ QueryCursor.prototype.next = async function next() {
   if (this._closed) {
     throw new MongooseError('Cannot call `next()` on a closed cursor');
   }
-  return new Promise((resolve, reject) => {
-    _next(this, function(error, doc) {
-      if (error) {
-        return reject(error);
-      }
-      resolve(doc);
+  const _this = this;
+  return cursorNextChannel.trace(function maybeTracedQueryCursorNext() {
+    return new Promise((resolve, reject) => {
+      _next(_this, function(error, doc) {
+        if (error) {
+          return reject(error);
+        }
+        resolve(doc);
+      });
     });
-  });
+  }, () => ({
+    operation: _this.query.op || 'find',
+    collection: _this.query.mongooseCollection.name,
+    database: _this.model.db?.name,
+    serverAddress: _this.model.db?.host,
+    serverPort: _this.model.db?.port,
+    batchSize: _this.options.batchSize || _this.query.options?.batchSize,
+    tailable: _this.options.tailable || _this.query.options?.tailable || false,
+    args: {
+      filter: _this.query.getFilter(),
+      options: _this.query._mongooseOptions
+    }
+  }));
 };
 
 /**