mongoose 8.17.2 → 8.18.0

package/lib/error/messages.js

@@ -43,5 +43,5 @@ msg.Date.max = 'Path `{PATH}` ({VALUE}) is after maximum allowed value ({MAX}).'
 msg.String = {};
 msg.String.enum = '`{VALUE}` is not a valid enum value for path `{PATH}`.';
 msg.String.match = 'Path `{PATH}` is invalid ({VALUE}).';
-msg.String.minlength = 'Path `{PATH}` (`{VALUE}`) is shorter than the minimum allowed length ({MINLENGTH}).';
-msg.String.maxlength = 'Path `{PATH}` (`{VALUE}`) is longer than the maximum allowed length ({MAXLENGTH}).';
+msg.String.minlength = 'Path `{PATH}` (`{VALUE}`, length {LENGTH}) is shorter than the minimum allowed length ({MINLENGTH}).';
+msg.String.maxlength = 'Path `{PATH}` (`{VALUE}`, length {LENGTH}) is longer than the maximum allowed length ({MAXLENGTH}).';

package/lib/options/schemaUnionOptions.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const SchemaTypeOptions = require('./schemaTypeOptions');
+
+/**
+ * The options defined on a Union schematype.
+ *
+ * @api public
+ * @inherits SchemaTypeOptions
+ * @constructor SchemaUnionOptions
+ */
+
+class SchemaUnionOptions extends SchemaTypeOptions {}
+
+const opts = require('./propertyOptions');
+
+/**
+ * If set, specifies the types that this union can take. Mongoose will cast
+ * the value to one of the given types.
+ *
+ * If not set, Mongoose will not cast the value to any specific type.
+ *
+ * @api public
+ * @property of
+ * @memberOf SchemaUnionOptions
+ * @type {Function|Function[]|string|string[]}
+ * @instance
+ */
+
+Object.defineProperty(SchemaUnionOptions.prototype, 'of', opts);
+
+module.exports = SchemaUnionOptions;

package/lib/schema/index.js

@@ -12,6 +12,8 @@ exports.Buffer = require('./buffer');
 exports.Date = require('./date');
 exports.Decimal128 = exports.Decimal = require('./decimal128');
 exports.DocumentArray = require('./documentArray');
+exports.Double = require('./double');
+exports.Int32 = require('./int32');
 exports.Map = require('./map');
 exports.Mixed = require('./mixed');
 exports.Number = require('./number');
@@ -19,8 +21,7 @@ exports.ObjectId = require('./objectId');
 exports.String = require('./string');
 exports.Subdocument = require('./subdocument');
 exports.UUID = require('./uuid');
-exports.Double = require('./double');
-exports.Int32 = require('./int32');
+exports.Union = require('./union');
 
 // alias
 

package/lib/schema/union.js

@@ -0,0 +1,105 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+const SchemaUnionOptions = require('../options/schemaUnionOptions');
+const SchemaType = require('../schemaType');
+
+const firstValueSymbol = Symbol('firstValue');
+
+/*!
+ * ignore
+ */
+
+class Union extends SchemaType {
+  constructor(key, options, schemaOptions = {}) {
+    super(key, options, 'Union');
+    if (!options || !Array.isArray(options.of) || options.of.length === 0) {
+      throw new Error('Union schema type requires an array of types');
+    }
+    this.schemaTypes = options.of.map(obj => options.parentSchema.interpretAsType(key, obj, schemaOptions));
+  }
+
+  cast(val, doc, init, prev, options) {
+    let firstValue = firstValueSymbol;
+    let lastError;
+    // Loop through each schema type in the union. If one of the schematypes returns a value that is `=== val`, then
+    // use `val`. Otherwise, if one of the schematypes casted successfully, use the first successfully casted value.
+    // Finally, if none of the schematypes casted successfully, throw the error from the last schema type in the union.
+    // The `=== val` check is a workaround to ensure that the original value is returned if it matches one of the schema types,
+    // avoiding cases like where numbers are casted to strings or dates even if the schema type is a number.
+    for (let i = 0; i < this.schemaTypes.length; ++i) {
+      try {
+        const casted = this.schemaTypes[i].cast(val, doc, init, prev, options);
+        if (casted === val) {
+          return casted;
+        }
+        if (firstValue === firstValueSymbol) {
+          firstValue = casted;
+        }
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    if (firstValue !== firstValueSymbol) {
+      return firstValue;
+    }
+    throw lastError;
+  }
+
+  // Setters also need to be aware of casting - we need to apply the setters of the entry in the union we choose.
+  applySetters(val, doc, init, prev, options) {
+    let firstValue = firstValueSymbol;
+    let lastError;
+    // Loop through each schema type in the union. If one of the schematypes returns a value that is `=== val`, then
+    // use `val`. Otherwise, if one of the schematypes casted successfully, use the first successfully casted value.
+    // Finally, if none of the schematypes casted successfully, throw the error from the last schema type in the union.
+    // The `=== val` check is a workaround to ensure that the original value is returned if it matches one of the schema types,
+    // avoiding cases like where numbers are casted to strings or dates even if the schema type is a number.
+    for (let i = 0; i < this.schemaTypes.length; ++i) {
+      try {
+        let castedVal = this.schemaTypes[i]._applySetters(val, doc, init, prev, options);
+        if (castedVal == null) {
+          castedVal = this.schemaTypes[i]._castNullish(castedVal);
+        } else {
+          castedVal = this.schemaTypes[i].cast(castedVal, doc, init, prev, options);
+        }
+        if (castedVal === val) {
+          return castedVal;
+        }
+        if (firstValue === firstValueSymbol) {
+          firstValue = castedVal;
+        }
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    if (firstValue !== firstValueSymbol) {
+      return firstValue;
+    }
+    throw lastError;
+  }
+
+  clone() {
+    const schematype = super.clone();
+
+    schematype.schemaTypes = this.schemaTypes.map(schemaType => schemaType.clone());
+    return schematype;
+  }
+}
+
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+Union.schemaName = 'Union';
+
+Union.defaultOptions = {};
+
+Union.prototype.OptionsConstructor = SchemaUnionOptions;
+
+module.exports = Union;

package/lib/schema.js

@@ -1525,7 +1525,7 @@ Object.defineProperty(Schema.prototype, 'base', {
  *
  * @param {String} path
  * @param {Object} obj constructor
- * @param {Object} options
+ * @param {Object} options schema options
  * @api private
  */
 
@@ -1539,7 +1539,6 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
     return clone;
   }
 
-
   // If this schema has an associated Mongoose object, use the Mongoose object's
   // copy of SchemaTypes re: gh-7158 gh-6933
   const MongooseTypes = this.base != null ? this.base.Schema.Types : Schema.Types;
@@ -1740,7 +1739,10 @@ Schema.prototype.interpretAsType = function(path, obj, options) {
       'https://bit.ly/mongoose-schematypes for a list of valid schema types.');
   }
 
-  const schemaType = new MongooseTypes[name](path, obj);
+  if (name === 'Union') {
+    obj.parentSchema = this;
+  }
+  const schemaType = new MongooseTypes[name](path, obj, options);
 
   if (schemaType.$isSchemaMap) {
     createMapNestedSchemaType(this, schemaType, path, obj, options);

package/lib/schemaType.js

@@ -1349,6 +1349,12 @@ SchemaType.prototype.doValidate = function(value, fn, scope, options) {
     validatorProperties.path = options && options.path ? options.path : path;
     validatorProperties.fullPath = this.$fullPath;
     validatorProperties.value = value;
+    if (typeof value === 'string') {
+      validatorProperties.length = value.length;
+      if (validatorProperties.value.length > 30) {
+        validatorProperties.value = validatorProperties.value.slice(0, 30) + '...';
+      }
+    }
 
     if (validator instanceof RegExp) {
       validate(validator.test(value), validatorProperties, scope);
@@ -1470,6 +1476,12 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
     validatorProperties.path = options && options.path ? options.path : path;
     validatorProperties.fullPath = this.$fullPath;
     validatorProperties.value = value;
+    if (typeof value === 'string') {
+      validatorProperties.length = value.length;
+      if (validatorProperties.value.length > 30) {
+        validatorProperties.value = validatorProperties.value.slice(0, 30) + '...';
+      }
+    }
     let ok = false;
 
     // Skip any explicit async validators. Validators that return a promise

package/package.json

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

package/types/collection.d.ts

@@ -1,46 +1,49 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
-  /*
-   * section collection.js
-   */
-  interface CollectionBase<T extends mongodb.Document> extends mongodb.Collection<T> {
-    /*
-     * Abstract methods. Some of these are already defined on the
-     * mongodb.Collection interface so they've been commented out.
+  export class BaseCollection<T extends mongodb.Document> extends mongodb.Collection<T> {
+    /**
+     * Collection constructor
+     * @param name name of the collection
+     * @param conn A MongooseConnection instance
+     * @param opts optional collection options
      */
+    constructor(name: string, conn: Connection, opts?: any);
+
+    /*
+    * Abstract methods. Some of these are already defined on the
+    * mongodb.Collection interface so they've been commented out.
+    */
     ensureIndex(...args: any[]): any;
     findAndModify(...args: any[]): any;
     getIndexes(...args: any[]): any;
 
+    /** Formatter for debug print args */
+    $format(arg: any, color?: boolean, shell?: boolean): string;
+    /** Debug print helper */
+    $print(name: string, i: string | number, args: any[], color?: boolean, shell?: boolean): void;
+
     /** The collection name */
-    collectionName: string;
+    get collectionName(): string;
     /** The Connection instance */
     conn: Connection;
     /** The collection name */
     name: string;
   }
 
-  export type BaseCollection<T extends mongodb.Document> = CollectionBase<T>;
-
   /*
    * section drivers/node-mongodb-native/collection.js
    */
-  interface Collection<T extends mongodb.Document = mongodb.Document> extends CollectionBase<T> {
+  class Collection<T extends mongodb.Document = mongodb.Document> extends BaseCollection<T> {
     /**
      * Collection constructor
      * @param name name of the collection
      * @param conn A MongooseConnection instance
      * @param opts optional collection options
      */
-    // eslint-disable-next-line @typescript-eslint/no-misused-new
-    new(name: string, conn: Connection, opts?: any): Collection<T>;
-    /** Formatter for debug print args */
-    $format(arg: any, color?: boolean, shell?: boolean): string;
-    /** Debug print helper */
-    $print(name: string, i: string | number, args: any[], color?: boolean, shell?: boolean): void;
+    constructor(name: string, conn: Connection, opts?: any);
+
     /** Retrieves information about this collections indexes. */
     getIndexes(): ReturnType<mongodb.Collection<T>['indexInformation']>;
   }
-  let Collection: Collection;
 }

package/types/connection.d.ts

@@ -71,8 +71,6 @@ declare module 'mongoose' {
       };
   }[keyof SchemaMap];
 
-  export type BaseConnection = Connection;
-
   class Connection extends events.EventEmitter implements SessionStarter {
     /** Runs a [db-level aggregate()](https://www.mongodb.com/docs/manual/reference/method/db.aggregate/) on this connection's underlying `db` */
     aggregate<ResultType = unknown>(pipeline?: PipelineStage[] | null, options?: AggregateOptions): Aggregate<Array<ResultType>>;
@@ -286,4 +284,5 @@ declare module 'mongoose' {
     withSession<T = any>(executor: (session: ClientSession) => Promise<T>): Promise<T>;
   }
 
+  export class BaseConnection extends Connection {}
 }

package/types/inferrawdoctype.d.ts

@@ -35,6 +35,10 @@ declare module 'mongoose' {
     TypeKey
   >;
 
+  type UnionToRawPathType<T extends readonly any[]> = T[number] extends infer U
+    ? ResolveRawPathType<U>
+    : never;
+
   /**
    * Same as inferSchemaType, except:
    *
@@ -109,11 +113,12 @@ declare module 'mongoose' {
                                                 IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
                                                   PathValueType extends MapConstructor | 'Map' ? Map<string, ResolveRawPathType<Options['of']>> :
                                                     IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolveRawPathType<Options['of']>> :
-                                                      PathValueType extends ArrayConstructor ? any[] :
-                                                        PathValueType extends typeof Schema.Types.Mixed ? any:
-                                                          IfEquals<PathValueType, ObjectConstructor> extends true ? any:
-                                                            IfEquals<PathValueType, {}> extends true ? any:
-                                                              PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                                PathValueType extends Record<string, any> ? InferRawDocType<PathValueType> :
-                                                                  unknown;
+                                                      PathValueType extends 'Union' | 'union' | typeof Schema.Types.Union ? Options['of'] extends readonly any[] ? UnionToRawPathType<Options['of']> : never :
+                                                        PathValueType extends ArrayConstructor ? any[] :
+                                                          PathValueType extends typeof Schema.Types.Mixed ? any:
+                                                            IfEquals<PathValueType, ObjectConstructor> extends true ? any:
+                                                              IfEquals<PathValueType, {}> extends true ? any:
+                                                                PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
+                                                                  PathValueType extends Record<string, any> ? InferRawDocType<PathValueType> :
+                                                                    unknown;
 }

package/types/inferschematype.d.ts

@@ -75,10 +75,7 @@ declare module 'mongoose' {
 
   type ApplySchemaOptions<T, O = DefaultSchemaOptions> = ResolveTimestamps<T, O>;
 
-  type ResolveTimestamps<T, O> = O extends { methods: any } | { statics: any } | { virtuals: any } | { timestamps?: false } ? T
-    // For some reason, TypeScript sets all the document properties to unknown
-    // if we use methods, statics, or virtuals. So avoid inferring timestamps
-    // if any of these are set for now. See gh-12807
+  type ResolveTimestamps<T, O> = O extends { timestamps?: false } ? T
     : O extends { timestamps: infer TimestampOptions } ? TimestampOptions extends true
       ? { createdAt: NativeDate; updatedAt: NativeDate; } & T
       : TimestampOptions extends SchemaTimestampsConfig
@@ -206,6 +203,10 @@ TypeHint<PathValueType>
  */
 type PathEnumOrString<T extends SchemaTypeOptions<string>['enum']> = T extends ReadonlyArray<infer E> ? E : T extends { values: any } ? PathEnumOrString<T['values']> : T extends Record<string, infer V> ? V : string;
 
+type UnionToType<T extends readonly any[]> = T[number] extends infer U
+  ? ResolvePathType<U>
+  : never;
+
 type IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
   ? true
   : T extends (typeof Number)
@@ -317,11 +318,12 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
                                                       IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
                                                         PathValueType extends MapConstructor | 'Map' ? Map<string, ResolvePathType<Options['of']>> :
                                                           IfEquals<PathValueType, typeof Schema.Types.Map> extends true ? Map<string, ResolvePathType<Options['of']>> :
-                                                            PathValueType extends ArrayConstructor ? any[] :
-                                                              PathValueType extends typeof Schema.Types.Mixed ? any:
-                                                                IfEquals<PathValueType, ObjectConstructor> extends true ? any:
-                                                                  IfEquals<PathValueType, {}> extends true ? any:
-                                                                    PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                                      PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
-                                                                        unknown,
+                                                            PathValueType extends 'Union' | 'union' | typeof Schema.Types.Union ? Options['of'] extends readonly any[] ? UnionToType<Options['of']> : never :
+                                                              PathValueType extends ArrayConstructor ? any[] :
+                                                                PathValueType extends typeof Schema.Types.Mixed ? any:
+                                                                  IfEquals<PathValueType, ObjectConstructor> extends true ? any:
+                                                                    IfEquals<PathValueType, {}> extends true ? any:
+                                                                      PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
+                                                                        PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, { typeKey: TypeKey }> :
+                                                                          unknown,
   TypeHint>;

package/types/schematypes.d.ts

@@ -188,7 +188,7 @@ declare module 'mongoose' {
     _id?: boolean;
 
     /** If set, specifies the type of this map's values. Mongoose will cast this map's values to the given type. */
-    of?: Function | SchemaDefinitionProperty<any>;
+    of?: Function | SchemaDefinitionProperty<any> | (Function | SchemaDefinitionProperty<any>)[];
 
     /** If true, uses Mongoose's default `_id` settings. Only allowed for ObjectIds */
     auto?: boolean;
@@ -569,6 +569,13 @@ declare module 'mongoose' {
         static defaultOptions: Record<string, any>;
       }
 
+      class Union extends SchemaType {
+        static schemaName: 'Union';
+
+        /** Default options for this SchemaType */
+        static defaultOptions: Record<string, any>;
+      }
+
       class UUID extends SchemaType {
         /** This schema type's name, to defend against minifiers that mangle function names. */
         static schemaName: 'UUID';