mongoose 8.14.2 → 8.15.0

package/lib/drivers/node-mongodb-native/connection.js

@@ -12,6 +12,7 @@ const pkg = require('../../../package.json');
 const processConnectionOptions = require('../../helpers/processConnectionOptions');
 const setTimeout = require('../../helpers/timers').setTimeout;
 const utils = require('../../utils');
+const Schema = require('../../schema');
 
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) connection implementation.
@@ -320,6 +321,20 @@ NativeConnection.prototype.createClient = async function createClient(uri, optio
     };
   }
 
+  const { schemaMap, encryptedFieldsMap } = this._buildEncryptionSchemas();
+
+  if ((Object.keys(schemaMap).length > 0 || Object.keys(encryptedFieldsMap).length) && !options.autoEncryption) {
+    throw new Error('Must provide `autoEncryption` when connecting with encrypted schemas.');
+  }
+
+  if (Object.keys(schemaMap).length > 0) {
+    options.autoEncryption.schemaMap = schemaMap;
+  }
+
+  if (Object.keys(encryptedFieldsMap).length > 0) {
+    options.autoEncryption.encryptedFieldsMap = encryptedFieldsMap;
+  }
+
   this.readyState = STATES.connecting;
   this._connectionString = uri;
 
@@ -343,6 +358,56 @@ NativeConnection.prototype.createClient = async function createClient(uri, optio
   return this;
 };
 
+/**
+ * Given a connection, which may or may not have encrypted models, build
+ * a schemaMap and/or an encryptedFieldsMap for the connection, combining all models
+ * into a single schemaMap and encryptedFields map.
+ *
+ * @returns the generated schemaMap and encryptedFieldsMap
+  */
+NativeConnection.prototype._buildEncryptionSchemas = function() {
+  const qeMappings = {};
+  const csfleMappings = {};
+
+  const encryptedModels = Object.values(this.models).filter(model => model.schema._hasEncryptedFields());
+
+  // If discriminators are configured for the collection, there might be multiple models
+  // pointing to the same namespace.  For this scenario, we merge all the schemas for each namespace
+  // into a single schema and then generate a schemaMap/encryptedFieldsMap for the combined schema.
+  for (const model of encryptedModels) {
+    const { schema, collection: { collectionName } } = model;
+    const namespace = `${this.$dbName}.${collectionName}`;
+    const mappings = schema.encryptionType() === 'csfle' ? csfleMappings : qeMappings;
+
+    mappings[namespace] ??= new Schema({}, { encryptionType: schema.encryptionType() });
+
+    const isNonRootDiscriminator = schema.discriminatorMapping && !schema.discriminatorMapping.isRoot;
+    if (isNonRootDiscriminator) {
+      const rootSchema = schema._baseSchema;
+      schema.eachPath((pathname) => {
+        if (rootSchema.path(pathname)) return;
+        if (!mappings[namespace]._hasEncryptedField(pathname)) return;
+
+        throw new Error(`Cannot have duplicate keys in discriminators with encryption. key=${pathname}`);
+      });
+    }
+
+    mappings[namespace].add(schema);
+  }
+
+  const schemaMap = Object.fromEntries(Object.entries(csfleMappings).map(
+    ([namespace, schema]) => ([namespace, schema._buildSchemaMap()])
+  ));
+
+  const encryptedFieldsMap = Object.fromEntries(Object.entries(qeMappings).map(
+    ([namespace, schema]) => ([namespace, schema._buildEncryptedFields()])
+  ));
+
+  return {
+    schemaMap, encryptedFieldsMap
+  };
+};
+
 /*!
  * ignore
  */

package/lib/drivers/node-mongodb-native/index.js

@@ -7,3 +7,4 @@
 exports.BulkWriteResult = require('./bulkWriteResult');
 exports.Collection = require('./collection');
 exports.Connection = require('./connection');
+exports.ClientEncryption = require('mongodb').ClientEncryption;

package/lib/error/serverSelection.js

@@ -49,6 +49,7 @@ class MongooseServerSelectionError extends MongooseError {
         this[key] = err[key];
       }
     }
+    this.cause = reason;
 
     return this;
   }

package/lib/helpers/model/discriminator.js

@@ -17,6 +17,51 @@ const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
   methods: true
 };
 
+/**
+ * Validate fields declared on the child schema when either schema is configured for encryption.  Specifically, this function ensures that:
+ *
+ * - any encrypted fields are declared on exactly one of the schemas (not both)
+ * - encrypted fields cannot be declared on either the parent or child schema, where the other schema declares the same field without encryption.
+ *
+ * @param {Schema} parentSchema
+ * @param {Schema} childSchema
+ */
+function validateDiscriminatorSchemasForEncryption(parentSchema, childSchema) {
+  if (parentSchema.encryptionType() == null && childSchema.encryptionType() == null) return;
+
+  const allSharedNestedPaths = setIntersection(
+    allNestedPaths(parentSchema),
+    allNestedPaths(childSchema)
+  );
+
+  for (const path of allSharedNestedPaths) {
+    if (parentSchema._hasEncryptedField(path) && childSchema._hasEncryptedField(path)) {
+      throw new Error(`encrypted fields cannot be declared on both the base schema and the child schema in a discriminator. path=${path}`);
+    }
+
+    if (parentSchema._hasEncryptedField(path) || childSchema._hasEncryptedField(path)) {
+      throw new Error(`encrypted fields cannot have the same path as a non-encrypted field for discriminators. path=${path}`);
+    }
+  }
+
+  function allNestedPaths(schema) {
+    return [...Object.keys(schema.paths), ...Object.keys(schema.singleNestedPaths)];
+  }
+
+  /**
+   * @param {Iterable<string>} i1
+   * @param {Iterable<string>} i2
+   */
+  function* setIntersection(i1, i2) {
+    const s1 = new Set(i1);
+    for (const item of i2) {
+      if (s1.has(item)) {
+        yield item;
+      }
+    }
+  }
+}
+
 /*!
  * ignore
  */
@@ -80,6 +125,8 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
     value = tiedValue;
   }
 
+  validateDiscriminatorSchemasForEncryption(model.schema, schema);
+
   function merge(schema, baseSchema) {
     // Retain original schema before merging base schema
     schema._baseSchema = baseSchema;

package/lib/helpers/query/cast$expr.js

@@ -69,8 +69,11 @@ const dateOperators = new Set([
 const expressionOperator = new Set(['$not']);
 
 module.exports = function cast$expr(val, schema, strictQuery) {
+  if (typeof val === 'boolean') {
+    return val;
+  }
   if (typeof val !== 'object' || val === null) {
-    throw new Error('`$expr` must be an object');
+    throw new Error('`$expr` must be an object or boolean literal');
   }
 
   return _castExpression(val, schema, strictQuery);

package/lib/model.js

@@ -69,7 +69,6 @@ const minimize = require('./helpers/minimize');
 const MongooseBulkSaveIncompleteError = require('./error/bulkSaveIncompleteError');
 const ObjectExpectedError = require('./error/objectExpected');
 const decorateBulkWriteResult = require('./helpers/model/decorateBulkWriteResult');
-
 const modelCollectionSymbol = Symbol('mongoose#Model#collection');
 const modelDbSymbol = Symbol('mongoose#Model#db');
 const modelSymbol = require('./helpers/symbols').modelSymbol;
@@ -3394,7 +3393,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     return bulkWriteResult;
   }
 
-  const validations = ops.map(op => castBulkWrite(this, op, options));
+  const validations = options?._skipCastBulkWrite ? [] : ops.map(op => castBulkWrite(this, op, options));
   const asyncLocalStorage = this.db.base.transactionAsyncLocalStorage?.getStore();
   if ((!options || !options.hasOwnProperty('session')) && asyncLocalStorage?.session != null) {
     options = { ...options, session: asyncLocalStorage.session };
@@ -3431,6 +3430,9 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     let validationErrors = [];
     const results = [];
     await new Promise((resolve) => {
+      if (validations.length === 0) {
+        return resolve();
+      }
       for (let i = 0; i < validations.length; ++i) {
         validations[i]((err) => {
           if (err == null) {
@@ -3568,8 +3570,9 @@ Model.bulkSave = async function bulkSave(documents, options) {
 
   await Promise.all(documents.map(doc => buildPreSavePromise(doc, options)));
 
-  const writeOperations = this.buildBulkWriteOperations(documents, { skipValidation: true, timestamps: options.timestamps });
-  const { bulkWriteResult, bulkWriteError } = await this.bulkWrite(writeOperations, { skipValidation: true, ...options }).then(
+  const writeOperations = this.buildBulkWriteOperations(documents, options);
+  const opts = { skipValidation: true, _skipCastBulkWrite: true, ...options };
+  const { bulkWriteResult, bulkWriteError } = await this.bulkWrite(writeOperations, opts).then(
     (res) => ({ bulkWriteResult: res, bulkWriteError: null }),
     (err) => ({ bulkWriteResult: null, bulkWriteError: err })
   );
@@ -3868,16 +3871,17 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
   }
 
   setDefaultOptions();
-  const discriminatorKey = this.schema.options.discriminatorKey;
 
-  const writeOperations = documents.reduce((accumulator, document, i) => {
+  const writeOperations = documents.map((document, i) => {
     if (!options.skipValidation) {
       if (!(document instanceof Document)) {
         throw new Error(`documents.${i} was not a mongoose document, documents must be an array of mongoose documents (instanceof mongoose.Document).`);
       }
-      const validationError = document.validateSync();
-      if (validationError) {
-        throw validationError;
+      if (options.validateBeforeSave == null || options.validateBeforeSave) {
+        const err = document.validateSync();
+        if (err != null) {
+          throw err;
+        }
       }
     }
 
@@ -3885,9 +3889,7 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
     if (isANewDocument) {
       const writeOperation = { insertOne: { document } };
       utils.injectTimestampsOption(writeOperation.insertOne, options.timestamps);
-      accumulator.push(writeOperation);
-
-      return accumulator;
+      return writeOperation;
     }
 
     const delta = document.$__delta();
@@ -3910,22 +3912,14 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
         }
       }
 
-      // Set the discriminator key, so bulk write casting knows which
-      // schema to use re: gh-13907
-      if (document[discriminatorKey] != null && !(discriminatorKey in where)) {
-        where[discriminatorKey] = document[discriminatorKey];
-      }
-
       document.$__version(where, delta);
       const writeOperation = { updateOne: { filter: where, update: changes } };
       utils.injectTimestampsOption(writeOperation.updateOne, options.timestamps);
-      accumulator.push(writeOperation);
-
-      return accumulator;
+      return writeOperation;
     }
 
-    return accumulator;
-  }, []);
+    return null;
+  }).filter(op => op !== null);
 
   return writeOperations;
 
@@ -4893,6 +4887,39 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   return model;
 };
 
+/**
+ * If auto encryption is enabled, returns a ClientEncryption instance that is configured with the same settings that
+ * Mongoose's underlying MongoClient is using.  If the client has not yet been configured, returns null.
+ *
+ * @returns {ClientEncryption | null}
+ */
+Model.clientEncryption = function clientEncryption() {
+  const ClientEncryption = this.base.driver.get().ClientEncryption;
+  if (!ClientEncryption) {
+    throw new Error('The mongodb driver must be used to obtain a ClientEncryption object.');
+  }
+
+  const client = this.collection?.conn?.client;
+
+  if (!client) return null;
+
+  const autoEncryptionOptions = client.options.autoEncryption;
+
+  if (!autoEncryptionOptions) return null;
+
+  const {
+    keyVaultNamespace,
+    keyVaultClient,
+    kmsProviders,
+    credentialProviders,
+    proxyOptions,
+    tlsOptions
+  } = autoEncryptionOptions;
+  return new ClientEncryption(keyVaultClient ?? client,
+    { keyVaultNamespace, kmsProviders, credentialProviders, proxyOptions, tlsOptions }
+  );
+};
+
 /**
  * Update this model to use the new connection, including updating all internal
  * references and creating a new `Collection` instance using the new connection.

package/lib/query.js

@@ -165,6 +165,32 @@ function Query(conditions, options, model, collection) {
   }
 }
 
+// Helper function to check if an object is empty or contains only empty objects/arrays
+function isEmptyFilter(obj) {
+  if (obj == null) return true;
+  if (typeof obj !== 'object') return true;
+  if (Object.keys(obj).length === 0) return true;
+
+  // Check $and, $or, $nor arrays
+  for (const key of ['$and', '$or', '$nor']) {
+    if (Array.isArray(obj[key])) {
+      // If array is empty or all elements are empty objects, consider it empty
+      if (obj[key].length === 0 || obj[key].every(item => isEmptyFilter(item))) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// Helper function to check for empty/invalid filter
+function checkRequireFilter(filter, options) {
+  if (options && options.requireFilter && isEmptyFilter(filter)) {
+    throw new Error('Empty or invalid filter not allowed with requireFilter enabled');
+  }
+}
+
 /*!
  * inherit mquery
  */
@@ -3111,6 +3137,7 @@ function _handleSortValue(val, key) {
  *
  * @param {Object|Query} [filter] mongodb selector
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {Boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
  * @see DeleteResult https://mongodb.github.io/node-mongodb-native/6.15/interfaces/DeleteResult.html
  * @see deleteOne https://mongodb.github.io/node-mongodb-native/6.15/classes/Collection.html#deleteOne
@@ -3148,6 +3175,9 @@ Query.prototype._deleteOne = async function _deleteOne() {
   this._applyTranslateAliases();
   this._castConditions();
 
+  // Check for empty/invalid filter with requireFilter option
+  checkRequireFilter(this._conditions, this.options);
+
   if (this.error() != null) {
     throw this.error();
   }
@@ -3183,6 +3213,7 @@ Query.prototype._deleteOne = async function _deleteOne() {
  *
  * @param {Object|Query} [filter] mongodb selector
  * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {Boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
  * @see DeleteResult https://mongodb.github.io/node-mongodb-native/6.15/interfaces/DeleteResult.html
  * @see deleteMany https://mongodb.github.io/node-mongodb-native/6.15/classes/Collection.html#deleteMany
@@ -3220,6 +3251,9 @@ Query.prototype._deleteMany = async function _deleteMany() {
   this._applyTranslateAliases();
   this._castConditions();
 
+  // Check for empty/invalid filter with requireFilter option
+  checkRequireFilter(this._conditions, this.options);
+
   if (this.error() != null) {
     throw this.error();
   }
@@ -3311,6 +3345,7 @@ function prepareDiscriminatorCriteria(query) {
  * - `maxTimeMS`: puts a time limit on the query - requires mongodb >= 2.6.0
  * - `runValidators`: if true, runs [update validators](https://mongoosejs.com/docs/validation.html#update-validators) on this command. Update validators validate the update operation against the model's schema.
  * - `setDefaultsOnInsert`: `true` by default. If `setDefaultsOnInsert` and `upsert` are true, mongoose will apply the [defaults](https://mongoosejs.com/docs/defaults.html) specified in the model's schema if a new document is created.
+ * - `requireFilter`: bool - if true, throws an error if the filter is empty (`{}`). Defaults to false.
  *
  * #### Example:
  *
@@ -3337,6 +3372,7 @@ function prepareDiscriminatorCriteria(query) {
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @param {Boolean} [options.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
+ * @param {Boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @see Tutorial https://mongoosejs.com/docs/tutorials/findoneandupdate.html
  * @see findAndModify command https://www.mongodb.com/docs/manual/reference/command/findAndModify/
  * @see ModifyResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html
@@ -3417,6 +3453,9 @@ Query.prototype._findOneAndUpdate = async function _findOneAndUpdate() {
   this._applyTranslateAliases();
   this._castConditions();
 
+  // Check for empty/invalid filter with requireFilter option
+  checkRequireFilter(this._conditions, this.options);
+
   _castArrayFilters(this);
 
   if (this.error()) {
@@ -3500,6 +3539,7 @@ Query.prototype._findOneAndUpdate = async function _findOneAndUpdate() {
  *
  * - `sort`: if multiple docs are found by the conditions, sets the sort order to choose which doc to update
  * - `maxTimeMS`: puts a time limit on the query - requires mongodb >= 2.6.0
+ * - `requireFilter`: bool - if true, throws an error if the filter is empty (`{}`). Defaults to false.
  *
  * #### Example:
  *
@@ -3512,6 +3552,7 @@ Query.prototype._findOneAndUpdate = async function _findOneAndUpdate() {
  * @param {Object} [filter]
  * @param {Object} [options]
  * @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
+ * @param {Boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
  * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
  * @return {Query} this
@@ -3551,6 +3592,9 @@ Query.prototype._findOneAndDelete = async function _findOneAndDelete() {
   this._applyTranslateAliases();
   this._castConditions();
 
+  // Check for empty/invalid filter with requireFilter option
+  checkRequireFilter(this._conditions, this.options);
+
   if (this.error() != null) {
     throw this.error();
   }
@@ -3590,6 +3634,7 @@ Query.prototype._findOneAndDelete = async function _findOneAndDelete() {
  * - `sort`: if multiple docs are found by the conditions, sets the sort order to choose which doc to update
  * - `maxTimeMS`: puts a time limit on the query - requires mongodb >= 2.6.0
  * - `includeResultMetadata`: if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
+ * - `requireFilter`: bool - if true, throws an error if the filter is empty (`{}`). Defaults to false.
  *
  * #### Example:
  *
@@ -3612,6 +3657,7 @@ Query.prototype._findOneAndDelete = async function _findOneAndDelete() {
  * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
  * @param {Boolean} [options.returnOriginal=null] An alias for the `new` option. `returnOriginal: false` is equivalent to `new: true`.
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {Boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
  * @api public
  */
@@ -3667,6 +3713,10 @@ Query.prototype.findOneAndReplace = function(filter, replacement, options) {
 Query.prototype._findOneAndReplace = async function _findOneAndReplace() {
   this._applyTranslateAliases();
   this._castConditions();
+
+  // Check for empty/invalid filter with requireFilter option
+  checkRequireFilter(this._conditions, this.options);
+
   if (this.error() != null) {
     throw this.error();
   }
@@ -3969,6 +4019,9 @@ async function _updateThunk(op) {
 
   this._castConditions();
 
+  // Check for empty/invalid filter with requireFilter option
+  checkRequireFilter(this._conditions, this.options);
+
   _castArrayFilters(this);
 
   if (this.error() != null) {
@@ -4119,6 +4172,7 @@ Query.prototype._replaceOne = async function _replaceOne() {
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @param {Boolean} [options.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
+ * @param {Boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
  * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
  * @see Query docs https://mongoosejs.com/docs/queries.html
@@ -4193,6 +4247,7 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @param {Boolean} [options.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
+ * @param {Boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
  * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
  * @see Query docs https://mongoosejs.com/docs/queries.html
@@ -4259,6 +4314,7 @@ Query.prototype.updateOne = function(conditions, doc, options, callback) {
  * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
  * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
  * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {Boolean} [options.requireFilter=false] If true, throws an error if the filter is empty (`{}`)
  * @return {Query} this
  * @see Model.update https://mongoosejs.com/docs/api/model.html#Model.update()
  * @see Query docs https://mongoosejs.com/docs/queries.html

package/lib/schema/array.js

@@ -718,6 +718,10 @@ SchemaArray.prototype.toJSONSchema = function toJSONSchema(options) {
   };
 };
 
+SchemaArray.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'array';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/bigint.js

@@ -254,6 +254,10 @@ SchemaBigInt.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('string', 'long', options?.useBsonType, isRequired);
 };
 
+SchemaBigInt.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'long';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/boolean.js

@@ -304,6 +304,10 @@ SchemaBoolean.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('boolean', 'bool', options?.useBsonType, isRequired);
 };
 
+SchemaBoolean.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'bool';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/buffer.js

@@ -314,6 +314,10 @@ SchemaBuffer.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('string', 'binData', options?.useBsonType, isRequired);
 };
 
+SchemaBuffer.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'binData';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/date.js

@@ -440,6 +440,10 @@ SchemaDate.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('string', 'date', options?.useBsonType, isRequired);
 };
 
+SchemaDate.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'date';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/decimal128.js

@@ -235,6 +235,10 @@ SchemaDecimal128.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('string', 'decimal', options?.useBsonType, isRequired);
 };
 
+SchemaDecimal128.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'decimal';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/double.js

@@ -218,6 +218,10 @@ SchemaDouble.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('number', 'double', options?.useBsonType, isRequired);
 };
 
+SchemaDouble.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'double';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/int32.js

@@ -260,6 +260,10 @@ SchemaInt32.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('number', 'int', options?.useBsonType, isRequired);
 };
 
+SchemaInt32.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'int';
+};
+
 
 /*!
  * Module exports.

package/lib/schema/map.js

@@ -95,6 +95,10 @@ class SchemaMap extends SchemaType {
 
     return result;
   }
+
+  autoEncryptionType() {
+    return 'object';
+  }
 }
 
 /**

package/lib/schema/objectId.js

@@ -304,6 +304,10 @@ SchemaObjectId.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('string', 'objectId', options?.useBsonType, isRequired);
 };
 
+SchemaObjectId.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'objectId';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/string.js

@@ -712,6 +712,10 @@ SchemaString.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('string', 'string', options?.useBsonType, isRequired);
 };
 
+SchemaString.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'string';
+};
+
 /*!
  * Module exports.
  */

package/lib/schema/uuid.js

@@ -298,6 +298,10 @@ SchemaUUID.prototype.toJSONSchema = function toJSONSchema(options) {
   return createJSONSchemaTypeDefinition('string', 'binData', options?.useBsonType, isRequired);
 };
 
+SchemaUUID.prototype.autoEncryptionType = function autoEncryptionType() {
+  return 'binData';
+};
+
 /*!
  * Module exports.
  */