mongoose 8.9.5 → 8.9.6

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);
       }
     }

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.6",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

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]);
-    }
-  }
-}
-```