mongoose 8.20.0 → 9.0.0-rc0

package/eslint.config.mjs

@@ -0,0 +1,198 @@
+import { defineConfig, globalIgnores } from 'eslint/config';
+import mochaNoOnly from 'eslint-plugin-mocha-no-only';
+import globals from 'globals';
+import tseslint from 'typescript-eslint';
+import js from '@eslint/js';
+
+export default defineConfig([
+  globalIgnores([
+    '**/tools',
+    '**/dist',
+    'test/files/*',
+    '**/benchmarks',
+    '**/*.min.js',
+    '**/docs/js/native.js',
+    '!**/.*',
+    '**/node_modules',
+    '**/.git',
+    '**/data'
+  ]),
+  js.configs.recommended,
+  // general options
+  {
+    languageOptions: {
+      globals: globals.node,
+      ecmaVersion: 2022, // nodejs 18.0.0,
+      sourceType: 'commonjs'
+    },
+    rules: {
+      'comma-style': 'error',
+
+      indent: ['error', 2, {
+        SwitchCase: 1,
+        VariableDeclarator: 2
+      }],
+
+      'keyword-spacing': 'error',
+      'no-whitespace-before-property': 'error',
+      'no-buffer-constructor': 'warn',
+      'no-console': 'off',
+      'no-constant-condition': 'off',
+      'no-multi-spaces': 'error',
+      'func-call-spacing': 'error',
+      'no-trailing-spaces': 'error',
+      'no-undef': 'error',
+      'no-unneeded-ternary': 'error',
+      'no-const-assign': 'error',
+      'no-useless-rename': 'error',
+      'no-dupe-keys': 'error',
+      'space-in-parens': ['error', 'never'],
+
+      'spaced-comment': ['error', 'always', {
+        block: {
+          markers: ['!'],
+          balanced: true
+        }
+      }],
+
+      'key-spacing': ['error', {
+        beforeColon: false,
+        afterColon: true
+      }],
+
+      'comma-spacing': ['error', {
+        before: false,
+        after: true
+      }],
+
+      'array-bracket-spacing': 1,
+
+      'arrow-spacing': ['error', {
+        before: true,
+        after: true
+      }],
+
+      'object-curly-spacing': ['error', 'always'],
+      'comma-dangle': ['error', 'never'],
+      'no-unreachable': 'error',
+      quotes: ['error', 'single'],
+      'quote-props': ['error', 'as-needed'],
+      semi: 'error',
+      'no-extra-semi': 'error',
+      'semi-spacing': 'error',
+      'no-spaced-func': 'error',
+      'no-throw-literal': 'error',
+      'space-before-blocks': 'error',
+      'space-before-function-paren': ['error', 'never'],
+      'space-infix-ops': 'error',
+      'space-unary-ops': 'error',
+      'no-var': 'warn',
+      'prefer-const': 'warn',
+      strict: ['error', 'global'],
+
+      'no-restricted-globals': ['error', {
+        name: 'context',
+        message: 'Don\'t use Mocha\'s global context'
+      }],
+
+      'no-prototype-builtins': 'off',
+      'no-empty': 'off',
+      'eol-last': 'warn',
+
+      'no-multiple-empty-lines': ['warn', {
+        max: 2
+      }]
+    }
+  },
+  // general typescript options
+  {
+    files: ['**/*.{ts,tsx}', '**/*.md/*.ts', '**/*.md/*.typescript'],
+    extends: [
+      tseslint.configs.recommended
+    ],
+    languageOptions: {
+      parserOptions: {
+        projectService: {
+          allowDefaultProject: [],
+          defaultProject: 'tsconfig.json'
+        }
+      }
+    },
+    rules: {
+      '@typescript-eslint/triple-slash-reference': 'off',
+      '@typescript-eslint/no-non-null-assertion': 'off',
+      '@typescript-eslint/no-empty-function': 'off',
+
+      'spaced-comment': ['error', 'always', {
+        block: {
+          markers: ['!'],
+          balanced: true
+        },
+
+        markers: ['/']
+      }],
+
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/ban-types': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      '@typescript-eslint/explicit-module-boundary-types': 'off',
+      '@typescript-eslint/prefer-optional-chain': 'error',
+      '@typescript-eslint/no-dupe-class-members': 'error',
+      '@typescript-eslint/no-redeclare': 'error',
+      '@typescript-eslint/space-infix-ops': 'off',
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/no-empty-object-type': 'off',
+      '@typescript-eslint/no-wrapper-object-types': 'off',
+      '@typescript-eslint/no-unused-expressions': 'off',
+      '@typescript-eslint/no-unsafe-function-type': 'off'
+    }
+  },
+  // type test specific options
+  {
+    files: ['test/types/**/*.ts'],
+    rules: {
+      '@typescript-eslint/no-empty-interface': 'off'
+    }
+  },
+  // test specific options (including type tests)
+  {
+    files: ['test/**/*.js', 'test/**/*.ts'],
+    ignores: ['deno*.mjs'],
+    plugins: {
+      'mocha-no-only': mochaNoOnly
+    },
+    languageOptions: {
+      globals: globals.mocha
+    },
+    rules: {
+      'no-self-assign': 'off',
+      'mocha-no-only/mocha-no-only': ['error']
+    }
+  },
+  // deno specific options
+  {
+    files: ['**/deno*.mjs'],
+    languageOptions: {
+      globals: {
+        // "globals" currently has no definition for deno
+        Deno: 'readonly'
+      }
+    }
+  },
+  // general options for module files
+  {
+    files: ['**/*.mjs'],
+    languageOptions: {
+      sourceType: 'module'
+    }
+  },
+  // doc script specific options
+  {
+    files: ['**/docs/js/**/*.js'],
+    languageOptions: {
+      globals: {
+        ...Object.fromEntries(Object.entries(globals.node).map(([key]) => [key, 'off'])),
+        ...globals.browser }
+    }
+  }
+]);

package/lib/aggregate.js

@@ -800,18 +800,11 @@ Aggregate.prototype.explain = async function explain(verbosity) {
 
   prepareDiscriminatorPipeline(this._pipeline, this._model.schema);
 
-  await new Promise((resolve, reject) => {
-    model.hooks.execPre('aggregate', this, error => {
-      if (error) {
-        const _opts = { error: error };
-        return model.hooks.execPost('aggregate', this, [null], _opts, error => {
-          reject(error);
-        });
-      } else {
-        resolve();
-      }
-    });
-  });
+  try {
+    await model.hooks.execPre('aggregate', this);
+  } catch (error) {
+    return await model.hooks.execPost('aggregate', this, [null], { error });
+  }
 
   const cursor = model.collection.aggregate(this._pipeline, this.options);
 
@@ -823,26 +816,10 @@ Aggregate.prototype.explain = async function explain(verbosity) {
   try {
     result = await cursor.explain(verbosity);
   } catch (error) {
-    await new Promise((resolve, reject) => {
-      const _opts = { error: error };
-      model.hooks.execPost('aggregate', this, [null], _opts, error => {
-        if (error) {
-          return reject(error);
-        }
-        return resolve();
-      });
-    });
+    return await model.hooks.execPost('aggregate', this, [null], { error });
   }
 
-  const _opts = { error: null };
-  await new Promise((resolve, reject) => {
-    model.hooks.execPost('aggregate', this, [result], _opts, error => {
-      if (error) {
-        return reject(error);
-      }
-      return resolve();
-    });
-  });
+  await model.hooks.execPost('aggregate', this, [result], { error: null });
 
   return result;
 };
@@ -1079,18 +1056,11 @@ Aggregate.prototype.exec = async function exec() {
   prepareDiscriminatorPipeline(this._pipeline, this._model.schema);
   stringifyFunctionOperators(this._pipeline);
 
-  await new Promise((resolve, reject) => {
-    model.hooks.execPre('aggregate', this, error => {
-      if (error) {
-        const _opts = { error: error };
-        return model.hooks.execPost('aggregate', this, [null], _opts, error => {
-          reject(error);
-        });
-      } else {
-        resolve();
-      }
-    });
-  });
+  try {
+    await model.hooks.execPre('aggregate', this);
+  } catch (error) {
+    return await model.hooks.execPost('aggregate', this, [null], { error });
+  }
 
   if (!this._pipeline.length) {
     throw new MongooseError('Aggregate has empty pipeline');
@@ -1103,27 +1073,10 @@ Aggregate.prototype.exec = async function exec() {
     const cursor = await collection.aggregate(this._pipeline, options);
     result = await cursor.toArray();
   } catch (error) {
-    await new Promise((resolve, reject) => {
-      const _opts = { error: error };
-      model.hooks.execPost('aggregate', this, [null], _opts, (error) => {
-        if (error) {
-          return reject(error);
-        }
-
-        resolve();
-      });
-    });
+    return await model.hooks.execPost('aggregate', this, [null], { error });
   }
 
-  const _opts = { error: null };
-  await new Promise((resolve, reject) => {
-    model.hooks.execPost('aggregate', this, [result], _opts, error => {
-      if (error) {
-        return reject(error);
-      }
-      return resolve();
-    });
-  });
+  await model.hooks.execPost('aggregate', this, [result], { error: null });
 
   return result;
 };
@@ -1186,24 +1139,15 @@ Aggregate.prototype.finally = function(onFinally) {
  *       console.log(doc.name);
  *     }
  *
- * Node.js 10.x supports async iterators natively without any flags. You can
- * enable async iterators in Node.js 8.x using the [`--harmony_async_iteration` flag](https://github.com/tc39/proposal-async-iteration/issues/117#issuecomment-346695187).
- *
- * **Note:** This function is not set if `Symbol.asyncIterator` is undefined. If
- * `Symbol.asyncIterator` is undefined, that means your Node.js version does not
- * support async iterators.
- *
  * @method [Symbol.asyncIterator]
  * @memberOf Aggregate
  * @instance
  * @api public
  */
 
-if (Symbol.asyncIterator != null) {
-  Aggregate.prototype[Symbol.asyncIterator] = function() {
-    return this.cursor({ useMongooseAggCursor: true }).transformNull()._transformForAsyncIterator();
-  };
-}
+Aggregate.prototype[Symbol.asyncIterator] = function() {
+  return this.cursor({ useMongooseAggCursor: true }).transformNull()._transformForAsyncIterator();
+};
 
 /*!
  * Helpers

package/lib/cast/bigint.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { Long } = require('bson');
+const { Long } = require('mongodb/lib/bson');
 
 /**
  * Given a value, cast it to a BigInt, or throw an `Error` if the value

package/lib/cast/double.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const assert = require('assert');
-const BSON = require('bson');
+const BSON = require('mongodb/lib/bson');
 const isBsonType = require('../helpers/isBsonType');
 
 /**

package/lib/cast/uuid.js

@@ -1,43 +1,31 @@
 'use strict';
 
-const MongooseBuffer = require('../types/buffer');
+const UUID = require('mongodb/lib/bson').UUID;
 
 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 (value instanceof UUID) {
+    return value;
   }
-
   if (typeof value === 'string') {
     if (UUID_FORMAT.test(value)) {
-      return stringToBinary(value);
+      return new UUID(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());
+      return new UUID(value.toString());
     }
   }
 
@@ -45,34 +33,3 @@ module.exports = function castUUID(value) {
 };
 
 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/cast.js

@@ -175,12 +175,12 @@ module.exports = function cast(schema, obj, options, context) {
         // If a substring of the input path resolves to an actual real path...
         if (schematype) {
           // Apply the casting; similar code for $elemMatch in schema/array.js
-          if (schematype.caster && schematype.caster.schema) {
+          if (schematype.schema) {
             remainingConds = {};
             pathLastHalf = split.slice(j).join('.');
             remainingConds[pathLastHalf] = val;
 
-            const ret = cast(schematype.caster.schema, remainingConds, options, context)[pathLastHalf];
+            const ret = cast(schematype.schema, remainingConds, options, context)[pathLastHalf];
             if (ret === void 0) {
               delete obj[path];
             } else {

package/lib/connection.js

@@ -1802,7 +1802,6 @@ Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
  * @param {String} name The database name
  * @param {Object} [options]
  * @param {Boolean} [options.useCache=false] If true, cache results so calling `useDb()` multiple times with the same name only creates 1 connection object.
- * @param {Boolean} [options.noListener=false] If true, the connection object will not make the db listen to events on the original connection. See [issue #9961](https://github.com/Automattic/mongoose/issues/9961).
  * @return {Connection} New Connection Object
  * @api public
  */

package/lib/cursor/aggregationCursor.js

@@ -63,34 +63,24 @@ util.inherits(AggregationCursor, Readable);
 
 function _init(model, c, agg) {
   if (!model.collection.buffer) {
-    model.hooks.execPre('aggregate', agg, function(err) {
-      if (err != null) {
-        _handlePreHookError(c, err);
-        return;
-      }
-      if (typeof agg.options?.cursor?.transform === 'function') {
-        c._transforms.push(agg.options.cursor.transform);
-      }
-
-      c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
-      c.emit('cursor', c.cursor);
-    });
+    model.hooks.execPre('aggregate', agg).then(() => onPreComplete(null), err => onPreComplete(err));
   } else {
     model.collection.emitter.once('queue', function() {
-      model.hooks.execPre('aggregate', agg, function(err) {
-        if (err != null) {
-          _handlePreHookError(c, err);
-          return;
-        }
+      model.hooks.execPre('aggregate', agg).then(() => onPreComplete(null), err => onPreComplete(err));
+    });
+  }
 
-        if (typeof agg.options?.cursor?.transform === 'function') {
-          c._transforms.push(agg.options.cursor.transform);
-        }
+  function onPreComplete(err) {
+    if (err != null) {
+      _handlePreHookError(c, err);
+      return;
+    }
+    if (typeof agg.options?.cursor?.transform === 'function') {
+      c._transforms.push(agg.options.cursor.transform);
+    }
 
-        c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
-        c.emit('cursor', c.cursor);
-      });
-    });
+    c.cursor = model.collection.aggregate(agg._pipeline, agg.options || {});
+    c.emit('cursor', c.cursor);
   }
 }
 

package/lib/cursor/queryCursor.js

@@ -49,7 +49,8 @@ function QueryCursor(query) {
   this._transforms = [];
   this.model = model;
   this.options = {};
-  model.hooks.execPre('find', query, (err) => {
+
+  const onPreComplete = (err) => {
     if (err != null) {
       if (err instanceof kareem.skipWrappedFunction) {
         const resultValue = err.args[0];
@@ -94,7 +95,9 @@ function QueryCursor(query) {
     } else {
       _getRawCursor(query, this);
     }
-  });
+  };
+
+  model.hooks.execPre('find', query).then(() => onPreComplete(null), err => onPreComplete(err));
 }
 
 util.inherits(QueryCursor, Readable);
@@ -588,12 +591,7 @@ function _populateBatch() {
 
 function _nextDoc(ctx, doc, pop, callback) {
   if (ctx.query._mongooseOptions.lean) {
-    return ctx.model.hooks.execPost('find', ctx.query, [[doc]], err => {
-      if (err != null) {
-        return callback(err);
-      }
-      callback(null, doc);
-    });
+    return ctx.model.hooks.execPost('find', ctx.query, [[doc]]).then(() => callback(null, doc), err => callback(err));
   }
 
   const { model, _fields, _userProvidedFields, options } = ctx.query;
@@ -601,12 +599,7 @@ function _nextDoc(ctx, doc, pop, callback) {
     if (err != null) {
       return callback(err);
     }
-    ctx.model.hooks.execPost('find', ctx.query, [[doc]], err => {
-      if (err != null) {
-        return callback(err);
-      }
-      callback(null, doc);
-    });
+    ctx.model.hooks.execPost('find', ctx.query, [[doc]]).then(() => callback(null, doc), err => callback(err));
   });
 }