mongoose 8.9.5 → 8.9.7

package/lib/aggregate.js

@@ -392,11 +392,23 @@ Aggregate.prototype.project = function(arg) {
  * @memberOf Aggregate
  * @instance
  * @param {Object} arg
+ * @param {Object|Array<Number>} arg.near GeoJSON point or coordinates array
  * @return {Aggregate}
  * @api public
  */
 
 Aggregate.prototype.near = function(arg) {
+  if (arg == null) {
+    throw new MongooseError('Aggregate `near()` must be called with non-nullish argument');
+  }
+  if (arg.near == null) {
+    throw new MongooseError('Aggregate `near()` argument must have a `near` property');
+  }
+  const coordinates = Array.isArray(arg.near) ? arg.near : arg.near.coordinates;
+  if (typeof arg.near === 'object' && (!Array.isArray(coordinates) || coordinates.length < 2 || coordinates.find(c => typeof c !== 'number'))) {
+    throw new MongooseError(`Aggregate \`near()\` argument has invalid coordinates, got "${coordinates}"`);
+  }
+
   const op = {};
   op.$geoNear = arg;
   return this.append(op);

package/lib/cast/uuid.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const MongooseBuffer = require('../types/buffer');
+
+const UUID_FORMAT = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i;
+const Binary = MongooseBuffer.Binary;
+
+module.exports = function castUUID(value) {
+  if (value == null) {
+    return value;
+  }
+
+  function newBuffer(initbuff) {
+    const buff = new MongooseBuffer(initbuff);
+    buff._subtype = 4;
+    return buff;
+  }
+
+  if (typeof value === 'string') {
+    if (UUID_FORMAT.test(value)) {
+      return stringToBinary(value);
+    } else {
+      throw new Error(`"${value}" is not a valid UUID string`);
+    }
+  }
+
+  if (Buffer.isBuffer(value)) {
+    return newBuffer(value);
+  }
+
+  if (value instanceof Binary) {
+    return newBuffer(value.value(true));
+  }
+
+  // Re: gh-647 and gh-3030, we're ok with casting using `toString()`
+  // **unless** its the default Object.toString, because "[object Object]"
+  // doesn't really qualify as useful data
+  if (value.toString && value.toString !== Object.prototype.toString) {
+    if (UUID_FORMAT.test(value.toString())) {
+      return stringToBinary(value.toString());
+    }
+  }
+
+  throw new Error(`"${value}" cannot be casted to a UUID`);
+};
+
+module.exports.UUID_FORMAT = UUID_FORMAT;
+
+/**
+ * Helper function to convert the input hex-string to a buffer
+ * @param {String} hex The hex string to convert
+ * @returns {Buffer} The hex as buffer
+ * @api private
+ */
+
+function hex2buffer(hex) {
+  // use buffer built-in function to convert from hex-string to buffer
+  const buff = hex != null && Buffer.from(hex, 'hex');
+  return buff;
+}
+
+/**
+ * Convert a String to Binary
+ * @param {String} uuidStr The value to process
+ * @returns {MongooseBuffer} The binary to store
+ * @api private
+ */
+
+function stringToBinary(uuidStr) {
+  // Protect against undefined & throwing err
+  if (typeof uuidStr !== 'string') uuidStr = '';
+  const hex = uuidStr.replace(/[{}-]/g, ''); // remove extra characters
+  const bytes = hex2buffer(hex);
+  const buff = new MongooseBuffer(bytes);
+  buff._subtype = 4;
+
+  return buff;
+}

package/lib/document.js

@@ -1147,7 +1147,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
         } else if (pathtype === 'nested' && valForKey == null) {
           this.$set(pathName, valForKey, constructing, options);
         }
-      } else if (valForKey !== void 0) {
+      } else {
         this.$set(pathName, valForKey, constructing, options);
       }
     }
@@ -4069,7 +4069,7 @@ Document.prototype.$__toObjectShallow = function $__toObjectShallow() {
  * @param {Boolean} [options.flattenMaps=false] if true, convert Maps to POJOs. Useful if you want to `JSON.stringify()` the result of `toObject()`.
  * @param {Boolean} [options.flattenObjectIds=false] if true, convert any ObjectIds in the result to 24 character hex strings.
  * @param {Boolean} [options.useProjection=false] - If true, omits fields that are excluded in this document's projection. Unless you specified a projection, this will omit any field that has `select: false` in the schema.
- * @return {Object} js object (not a POJO)
+ * @return {Object} document as a plain old JavaScript object (POJO). This object may contain ObjectIds, Maps, Dates, mongodb.Binary, Buffers, and other non-POJO values.
  * @see mongodb.Binary https://mongodb.github.io/node-mongodb-native/4.9/classes/Binary.html
  * @api public
  * @memberOf Document

package/lib/helpers/document/applyDefaults.js

@@ -19,6 +19,9 @@ module.exports = function applyDefaults(doc, fields, exclude, hasIncludedChildre
     const type = doc.$__schema.paths[p];
     const path = type.splitPath();
     const len = path.length;
+    if (path[len - 1] === '$*') {
+      continue;
+    }
     let included = false;
     let doc_ = doc._doc;
     for (let j = 0; j < len; ++j) {

package/lib/schema/uuid.js

@@ -7,43 +7,13 @@
 const MongooseBuffer = require('../types/buffer');
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
+const castUUID = require('../cast/uuid');
 const utils = require('../utils');
 const handleBitwiseOperator = require('./operators/bitwise');
 
-const UUID_FORMAT = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i;
+const UUID_FORMAT = castUUID.UUID_FORMAT;
 const Binary = MongooseBuffer.Binary;
 
-/**
- * Helper function to convert the input hex-string to a buffer
- * @param {String} hex The hex string to convert
- * @returns {Buffer} The hex as buffer
- * @api private
- */
-
-function hex2buffer(hex) {
-  // use buffer built-in function to convert from hex-string to buffer
-  const buff = hex != null && Buffer.from(hex, 'hex');
-  return buff;
-}
-
-/**
- * Convert a String to Binary
- * @param {String} uuidStr The value to process
- * @returns {MongooseBuffer} The binary to store
- * @api private
- */
-
-function stringToBinary(uuidStr) {
-  // Protect against undefined & throwing err
-  if (typeof uuidStr !== 'string') uuidStr = '';
-  const hex = uuidStr.replace(/[{}-]/g, ''); // remove extra characters
-  const bytes = hex2buffer(hex);
-  const buff = new MongooseBuffer(bytes);
-  buff._subtype = 4;
-
-  return buff;
-}
-
 /**
  * Convert binary to a uuid string
  * @param {Buffer|Binary|String} uuidBin The value to process
@@ -109,44 +79,7 @@ SchemaUUID.prototype.constructor = SchemaUUID;
  * ignore
  */
 
-SchemaUUID._cast = function(value) {
-  if (value == null) {
-    return value;
-  }
-
-  function newBuffer(initbuff) {
-    const buff = new MongooseBuffer(initbuff);
-    buff._subtype = 4;
-    return buff;
-  }
-
-  if (typeof value === 'string') {
-    if (UUID_FORMAT.test(value)) {
-      return stringToBinary(value);
-    } else {
-      throw new CastError(SchemaUUID.schemaName, value, this.path);
-    }
-  }
-
-  if (Buffer.isBuffer(value)) {
-    return newBuffer(value);
-  }
-
-  if (value instanceof Binary) {
-    return newBuffer(value.value(true));
-  }
-
-  // Re: gh-647 and gh-3030, we're ok with casting using `toString()`
-  // **unless** its the default Object.toString, because "[object Object]"
-  // doesn't really qualify as useful data
-  if (value.toString && value.toString !== Object.prototype.toString) {
-    if (UUID_FORMAT.test(value.toString())) {
-      return stringToBinary(value.toString());
-    }
-  }
-
-  throw new CastError(SchemaUUID.schemaName, value, this.path);
-};
+SchemaUUID._cast = castUUID;
 
 /**
  * Attaches a getter for all UUID instances.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "8.9.5",
+  "version": "8.9.7",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",
@@ -28,8 +28,8 @@
     "sift": "17.1.3"
   },
   "devDependencies": {
-    "@babel/core": "7.26.0",
-    "@babel/preset-env": "7.26.0",
+    "@babel/core": "7.26.7",
+    "@babel/preset-env": "7.26.7",
     "@typescript-eslint/eslint-plugin": "^8.19.1",
     "@typescript-eslint/parser": "^8.19.1",
     "acquit": "1.3.0",
@@ -46,14 +46,14 @@
     "eslint-plugin-markdown": "^5.1.0",
     "eslint-plugin-mocha-no-only": "1.2.0",
     "express": "^4.19.2",
-    "fs-extra": "~11.2.0",
+    "fs-extra": "~11.3.0",
     "highlight.js": "11.11.1",
     "lodash.isequal": "4.5.0",
     "lodash.isequalwith": "4.4.0",
     "markdownlint-cli2": "^0.17.1",
-    "marked": "15.0.4",
+    "marked": "15.0.6",
     "mkdirp": "^3.0.1",
-    "mocha": "11.0.1",
+    "mocha": "11.1.0",
     "moment": "2.30.1",
     "mongodb-memory-server": "10.1.3",
     "ncp": "^2.0.0",
@@ -63,8 +63,8 @@
     "sinon": "19.0.2",
     "stream-browserify": "3.0.0",
     "tsd": "0.31.2",
-    "typescript": "5.7.2",
-    "uuid": "11.0.3",
+    "typescript": "5.7.3",
+    "uuid": "11.0.5",
     "webpack": "5.97.1"
   },
   "directories": {

package/types/expressions.d.ts

@@ -2301,6 +2301,18 @@ declare module 'mongoose' {
       }
     }
 
+    export interface Median {
+      /**
+       * Returns an approximation of the median, the 50th percentile, as a scalar value.
+       *
+       * @see https://www.mongodb.com/docs/v7.0/reference/operator/aggregation/median/
+       */
+      $median: {
+        input: number | Expression,
+        method: 'approximate'
+      }
+    }
+
     export interface StdDevPop {
       /**
        * Calculates the population standard deviation of the input values. Use if the values encompass the entire
@@ -2859,6 +2871,7 @@ declare module 'mongoose' {
     Expression.Locf |
     Expression.Max |
     Expression.MaxN |
+    Expression.Median |
     Expression.Min |
     Expression.MinN |
     Expression.Push |
@@ -2891,6 +2904,7 @@ declare module 'mongoose' {
     Expression.ExpMovingAvg |
     Expression.Integral |
     Expression.Max |
+    Expression.Median |
     Expression.Min |
     Expression.StdDevPop |
     Expression.StdDevSamp |
@@ -2963,6 +2977,7 @@ declare module 'mongoose' {
     Expression.LastN |
     Expression.Max |
     Expression.MaxN |
+    Expression.Median |
     Expression.MergeObjects |
     Expression.Min |
     Expression.MinN |

package/valnotes.md

@@ -1,85 +0,0 @@
-## sift where
-
-```
-      it('match prevents using $where', async function() {
-        const ParentSchema = new Schema({
-          name: String,
-          child: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Child'
-          },
-          children: [{
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Child'
-          }]
-        });
-
-        const ChildSchema = new Schema({
-          name: String
-        });
-        ChildSchema.virtual('parent', {
-          ref: 'Parent',
-          localField: '_id',
-          foreignField: 'parent'
-        });
-
-        const Parent = db.model('Parent', ParentSchema);
-        const Child = db.model('Child', ChildSchema);
-
-        const child = await Child.create({ name: 'Luke' });
-        const parent = await Parent.create({ name: 'Anakin', child: child._id });
-
-        await assert.rejects(
-          () => Parent.findOne().populate({ path: 'child', match: () => ({ $where: 'typeof console !== "undefined" ? doesNotExist("foo") : true;' }) }),
-          /Cannot use \$where filter with populate\(\) match/
-        );
-        await assert.rejects(
-          () => Parent.find().populate({ path: 'child', match: () => ({ $where: 'typeof console !== "undefined" ? doesNotExist("foo") : true;' }) }),
-          /Cannot use \$where filter with populate\(\) match/
-        );
-        await assert.rejects(
-          () => parent.populate({ path: 'child', match: () => ({ $where: 'typeof console !== "undefined" ? doesNotExist("foo") : true;' }) }),
-          /Cannot use \$where filter with populate\(\) match/
-        );
-        await assert.rejects(
-          () => Child.find().populate({ path: 'parent', match: () => ({ $where: 'typeof console !== "undefined" ? doesNotExist("foo") : true;' }) }),
-          /Cannot use \$where filter with populate\(\) match/
-        );
-        await assert.rejects(
-          () => Child.find().populate({ path: 'parent', match: () => ({ $or: [{ $where: 'typeof console !== "undefined" ? doesNotExist("foo") : true;' }] }) }),
-          /Cannot use \$where filter with populate\(\) match/
-        );
-        await assert.rejects(
-          () => Child.find().populate({ path: 'parent', match: () => ({ $and: [{ $where: 'typeof console !== "undefined" ? doesNotExist("foo") : true;' }] }) }),
-          /Cannot use \$where filter with populate\(\) match/
-        );
-
-        class MyClass {}
-        MyClass.prototype.$where = 'typeof console !== "undefined" ? doesNotExist("foo") : true;';
-        // OK because sift only looks through own properties
-        await Child.find().populate({ path: 'parent', match: () => new MyClass() });
-      });
-```
-
-```
-/**
- * Throw an error if there are any $where keys
- */
-
-function throwOn$where(match) {
-  if (match == null) {
-    return;
-  }
-  if (typeof match !== 'object') {
-    return;
-  }
-  for (const key of Object.keys(match)) {
-    if (key === '$where') {
-      throw new MongooseError('Cannot use $where filter with populate() match');
-    }
-    if (match[key] != null && typeof match[key] === 'object') {
-      throwOn$where(match[key]);
-    }
-  }
-}
-```