mongoose 7.8.8 → 7.8.10

package/gh-16033.ts

@@ -0,0 +1,35 @@
+import mongoose, { Schema, Model, PipelineStage } from 'mongoose';
+
+// Simple Item schema
+const itemSchema = new Schema({ text: String, published: Boolean });
+const Item: Model<any> = mongoose.model('Item', itemSchema);
+
+type UnionSubPipelineStage = Exclude<
+  PipelineStage,
+  PipelineStage.Out | PipelineStage.Merge
+>;
+
+function isUnionSubPipelineStage(stage: PipelineStage): stage is UnionSubPipelineStage {
+  return !('$out' in stage) && !('$merge' in stage);
+}
+
+function toUnionSubPipeline(stages: PipelineStage[]): UnionSubPipelineStage[] {
+  if (!stages.every(isUnionSubPipelineStage)) {
+    throw new Error('unionWith pipeline cannot include $out or $merge');
+  }
+  return stages; // already narrowed, no `as`
+}
+
+// Create base pipeline using aggregate builder
+const basePipeline = Item.aggregate([
+  { $match: { published: true } },
+  { $out: 'test' }
+]);
+
+// Try to reuse pipeline in unionWith - TypeScript error occurs here
+const result = Item.aggregate()
+  .match({ text: 'example' })
+  .unionWith({
+    coll: 'other_items',
+    pipeline: toUnionSubPipeline(basePipeline.pipeline()) // ❌ TypeScript error
+  });

package/lib/document.js

@@ -60,6 +60,7 @@ let MongooseArray;
 let Embedded;
 
 const specialProperties = utils.specialProperties;
+const hasOwnProperty = utils.object.hasOwnProperty;
 
 const VERSION_INC = 2;
 
@@ -1880,7 +1881,9 @@ Document.prototype.get = function(path, type, options) {
 
   // Fast path if we know we're just accessing top-level path on the document:
   // just get the schema path, avoid `$__path()` because that does string manipulation
-  let schema = noDottedPath ? this.$__schema.paths[path] : this.$__path(path);
+  let schema = noDottedPath ?
+    hasOwnProperty(this.$__schema.paths, path) ? this.$__schema.paths[path] : undefined :
+    this.$__path(path);
   if (schema == null) {
     schema = this.$__schema.virtualpath(path);
 
@@ -1890,7 +1893,7 @@ Document.prototype.get = function(path, type, options) {
   }
 
   if (noDottedPath) {
-    let obj = this._doc[path];
+    let obj = hasOwnProperty(this._doc, path) ? this._doc[path] : undefined;
     if (adhoc) {
       obj = adhoc.cast(obj);
     }
@@ -1917,6 +1920,10 @@ Document.prototype.get = function(path, type, options) {
   }
 
   for (let i = 0, l = pieces.length; i < l; i++) {
+    if (specialProperties.has(pieces[i])) {
+      return undefined;
+    }
+
     if (obj && obj._doc) {
       obj = obj._doc;
     }
@@ -1938,7 +1945,7 @@ Document.prototype.get = function(path, type, options) {
 
   if (schema != null && options.getters !== false) {
     obj = schema.applyGetters(obj, this);
-  } else if (this.$__schema.nested[path] && options.virtuals) {
+  } else if (hasOwnProperty(this.$__schema.nested, path) && options.virtuals) {
     // Might need to apply virtuals if this is a nested path
     return applyVirtuals(this, clone(obj) || {}, { path: path });
   }

package/lib/helpers/query/sanitizeFilter.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const MongooseError = require('../../error/mongooseError');
 const hasDollarKeys = require('./hasDollarKeys');
 const { trustedSymbol } = require('./trusted');
 
@@ -17,12 +18,14 @@ module.exports = function sanitizeFilter(filter) {
   const filterKeys = Object.keys(filter);
   for (const key of filterKeys) {
     const value = filter[key];
-    if (value != null && value[trustedSymbol]) {
+    if (value?.[trustedSymbol]) {
       continue;
     }
-    if (key === '$and' || key === '$or') {
+    if (key === '$and' || key === '$or' || key === '$nor') {
       sanitizeFilter(value);
       continue;
+    } else if (key === '$jsonSchema' || key === '$where' || key === '$expr' || key === '$text') {
+      throw new MongooseError(key + ' is not allowed with sanitizeFilter');
     }
 
     if (hasDollarKeys(value)) {

package/lib/helpers/query/trusted.js

@@ -5,7 +5,7 @@ const trustedSymbol = Symbol('mongoose#trustedSymbol');
 exports.trustedSymbol = trustedSymbol;
 
 exports.trusted = function trusted(obj) {
-  if (obj == null || typeof obj !== 'object') {
+  if (obj == null || (typeof obj !== 'object' && typeof obj !== 'function')) {
     return obj;
   }
   obj[trustedSymbol] = true;

package/lib/schema/bigint.js

@@ -69,7 +69,7 @@ SchemaBigInt.setters = [];
  * #### Example:
  *
  *     // Convert bigints to numbers
- *     mongoose.Schema.BigInt.get(v => v == null ? v : Number(v));
+ *     mongoose.Schema.Types.BigInt.get(v => typeof v === 'bigint' ? Number(v) : v);
  *
  * @param {Function} getter
  * @return {this}

package/lib/schema/buffer.js

@@ -77,11 +77,11 @@ SchemaBuffer.setters = [];
  *
  * #### Example:
  *
- *     // Always convert to string when getting an ObjectId
- *     mongoose.Schema.Types.Buffer.get(v => v.toString('hex'));
+ *     // Always convert to string when getting a buffer
+ *     mongoose.Schema.Types.Buffer.get(v => Buffer.isBuffer(v) ? v.toString('hex') : v);
  *
- *     const Model = mongoose.model('Test', new Schema({ buf: Buffer } }));
- *     typeof (new Model({ buf: Buffer.fromString('hello') }).buf); // 'string'
+ *     const Model = mongoose.model('Test', new Schema({ buf: Buffer }));
+ *     typeof (new Model({ buf: Buffer.from('hello') }).buf); // 'string'
  *
  * @param {Function} getter
  * @return {this}

package/lib/schema/date.js

@@ -78,7 +78,7 @@ SchemaDate.setters = [];
  * #### Example:
  *
  *     // Always convert Dates to string
- *     mongoose.Date.get(v => v.toString());
+ *     mongoose.Date.get(v => v instanceof Date ? v.toString() : v);
  *
  *     const Model = mongoose.model('Test', new Schema({ date: { type: Date, default: () => new Date() } }));
  *     typeof (new Model({}).date); // 'string'

package/lib/schema/decimal128.js

@@ -73,7 +73,7 @@ Decimal128.setters = [];
  * #### Example:
  *
  *     // Automatically convert Decimal128s to Numbers
- *     mongoose.Schema.Decimal128.get(v => v == null ? v : Number(v));
+ *     mongoose.Schema.Types.Decimal128.get(v => v instanceof mongoose.Types.Decimal128 ? Number(v) : v);
  *
  * @param {Function} getter
  * @return {this}

package/lib/schema/number.js

@@ -32,7 +32,7 @@ function SchemaNumber(key, options) {
  * #### Example:
  *
  *     // Make all numbers round down
- *     mongoose.Number.get(function(v) { return Math.floor(v); });
+ *     mongoose.Number.get(function(v) { return typeof v === 'number' ? Math.floor(v) : v; });
  *
  *     const Model = mongoose.model('Test', new Schema({ test: Number }));
  *     new Model({ test: 3.14 }).test; // 3

package/lib/schema/objectid.js

@@ -58,8 +58,9 @@ ObjectId.prototype.OptionsConstructor = SchemaObjectIdOptions;
  *
  * #### Example:
  *
- *     // Always convert to string when getting an ObjectId
- *     mongoose.ObjectId.get(v => v.toString());
+ *     // Convert actual ObjectId values to strings when getting an ObjectId. Check for
+ *     // instanceof ObjectId first so null/undefined values and populated documents are left as-is.
+ *     mongoose.ObjectId.get(v => v instanceof mongoose.Types.ObjectId ? v.toString() : v);
  *
  *     const Model = mongoose.model('Test', new Schema({}));
  *     typeof (new Model({})._id); // 'string'

package/lib/schema/string.js

@@ -107,8 +107,9 @@ SchemaString._defaultCaster = v => {
  *
  * #### Example:
  *
- *     // Make all numbers round down
- *     mongoose.Schema.String.get(v => v.toLowerCase());
+ *     // Make all strings lowercase. Check for string type before calling `toLowerCase()`
+ *     // to account for null/undefined values as well as populated docs.
+ *     mongoose.Schema.Types.String.get(v => typeof v === 'string' ? v.toLowerCase() : v);
  *
  *     const Model = mongoose.model('Test', new Schema({ test: String }));
  *     new Model({ test: 'FOO' }).test; // 'foo'

package/lib/schema.js

@@ -996,7 +996,7 @@ reserved.collection = 1;
 
 Schema.prototype.path = function(path, obj) {
   if (obj === undefined) {
-    if (this.paths[path] != null) {
+    if (Object.prototype.hasOwnProperty.call(this.paths, path)) {
       return this.paths[path];
     }
     // Convert to '.$' to check subpaths re: gh-6405
@@ -1024,9 +1024,15 @@ Schema.prototype.path = function(path, obj) {
       : undefined;
   }
 
+  const subpaths = path.indexOf('.') === -1 ? [path] : path.split('.');
+  const last = subpaths.pop();
+  if (utils.specialProperties.has(last)) {
+    throw new Error('Cannot set special property `' + last + '` on a schema');
+  }
+
   // some path names conflict with document methods
-  const firstPieceOfPath = path.split('.')[0];
-  if (reserved[firstPieceOfPath] && !this.options.suppressReservedKeysWarning) {
+  const firstPieceOfPath = subpaths.length === 0 ? last : subpaths[0];
+  if (Object.prototype.hasOwnProperty.call(reserved, firstPieceOfPath) && !this.options.suppressReservedKeysWarning) {
     const errorMessage = `\`${firstPieceOfPath}\` is a reserved schema pathname and may break some functionality. ` +
       'You are allowed to use it, but use at your own risk. ' +
       'To disable this warning pass `suppressReservedKeysWarning` as a schema option.';
@@ -1039,8 +1045,6 @@ Schema.prototype.path = function(path, obj) {
   }
 
   // update the tree
-  const subpaths = path.split(/\./);
-  const last = subpaths.pop();
   let branch = this.tree;
   let fullPath = '';
 
@@ -2702,7 +2706,7 @@ Schema.prototype._getPathType = function(path) {
           };
         }
         return { schema: foundschema, pathType: 'real' };
-      } else if (p === parts.length && schema.nested[trypath]) {
+      } else if (p === parts.length && Object.prototype.hasOwnProperty.call(schema.nested, trypath)) {
         return { schema: schema, pathType: 'nested' };
       }
     }

package/package.json

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

package/startmdb.mjs

@@ -0,0 +1,19 @@
+import { MongoMemoryReplSet } from 'mongodb-memory-server';
+
+const replSet = await MongoMemoryReplSet.create({
+  binary: {
+    systemBinary: '/home/v/libs/mongodb-linux-x86_64-enterprise-ubuntu2404-8.2.0/bin/mongod'
+  },
+  instanceOpts: [
+    {
+      port: 27017
+    }
+  ],
+  replSet: {
+    storageEngine: 'inMemory',
+    count: 1
+  }
+});
+
+const uri = replSet.getUri();
+console.log(uri);

package/step1.mjs

@@ -0,0 +1,44 @@
+import { tool } from 'ai';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+
+const execFileAsync = promisify(execFile);
+
+async function run(command, args) {
+  const { stdout } = await execFileAsync(command, args);
+  return stdout.trim();
+}
+
+function logToolCall(name, preview) {
+  console.log(`\n> ${name} ${preview}`);
+}
+
+const git = tool({
+  description: 'Run a git command like log or diff',
+  inputSchema: z.object({
+    subcommand: z.enum(['log', 'diff', 'show']),
+    args: z.array(z.string()).default([])
+  }),
+  execute: async({ subcommand, args }) => {
+    logToolCall('git', [subcommand, ...args].join(' '));
+    return run('git', [subcommand, ...args]);
+  }
+});
+
+import { generateText, stepCountIs } from 'ai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+
+const google = createGoogleGenerativeAI({
+  apiKey: process.env.GEMINI_API_KEY
+});
+
+const result = await generateText({
+  model: google('gemini-2.5-flash'),
+  stopWhen: stepCountIs(10),
+  system: 'Summarize recent git commits into a concise changelog entry. Focus on user-facing changes.',
+  prompt: 'Summarize the last 20 commits',
+  tools: { git }
+});
+
+console.log(result.text);