mongoose 8.10.1 → 8.11.0

package/types/index.d.ts

@@ -204,30 +204,32 @@ declare module 'mongoose' {
   }
 
   export interface ToObjectOptions<THydratedDocumentType = HydratedDocument<unknown>> {
-    /** apply all getters (path and virtual getters) */
-    getters?: boolean;
-    /** apply virtual getters (can override getters option) */
-    virtuals?: boolean | string[];
     /** if `options.virtuals = true`, you can set `options.aliases = false` to skip applying aliases. This option is a no-op if `options.virtuals = false`. */
     aliases?: boolean;
+    /** if true, replace any conventionally populated paths with the original id in the output. Has no affect on virtual populated paths. */
+    depopulate?: boolean;
+    /** if true, convert Maps to POJOs. Useful if you want to `JSON.stringify()` the result of `toObject()`. */
+    flattenMaps?: boolean;
+    /** if true, convert any ObjectIds in the result to 24 character hex strings. */
+    flattenObjectIds?: boolean;
+    /** apply all getters (path and virtual getters) */
+    getters?: boolean;
     /** remove empty objects (defaults to true) */
     minimize?: boolean;
+    /** If true, the resulting object will only have fields that are defined in the document's schema. By default, `toJSON()` & `toObject()` returns all fields in the underlying document from MongoDB, including ones that are not listed in the schema. */
+    schemaFieldsOnly?: boolean;
     /** if set, mongoose will call this function to allow you to transform the returned object */
     transform?: boolean | ((
       doc: THydratedDocumentType,
       ret: Record<string, any>,
       options: ToObjectOptions<THydratedDocumentType>
     ) => any);
-    /** if true, replace any conventionally populated paths with the original id in the output. Has no affect on virtual populated paths. */
-    depopulate?: boolean;
-    /** if false, exclude the version key (`__v` by default) from the output */
-    versionKey?: boolean;
-    /** if true, convert Maps to POJOs. Useful if you want to `JSON.stringify()` the result of `toObject()`. */
-    flattenMaps?: boolean;
-    /** if true, convert any ObjectIds in the result to 24 character hex strings. */
-    flattenObjectIds?: boolean;
     /** If true, omits fields that are excluded in this document's projection. Unless you specified a projection, this will omit any field that has `select: false` in the schema. */
     useProjection?: boolean;
+    /** if false, exclude the version key (`__v` by default) from the output */
+    versionKey?: boolean;
+    /** apply virtual getters (can override getters option) */
+    virtuals?: boolean | string[];
   }
 
   export type DiscriminatorModel<M, T> = T extends Model<infer T, infer TQueryHelpers, infer TInstanceMethods, infer TVirtuals>
@@ -712,47 +714,53 @@ declare module 'mongoose' {
     [K in keyof T]: FlattenProperty<T[K]>;
   };
 
-  export type BufferToBinaryProperty<T> = T extends Buffer
-    ? mongodb.Binary
-    : T extends Types.DocumentArray<infer ItemType>
-      ? Types.DocumentArray<BufferToBinary<ItemType>>
-      : T extends Types.Subdocument<unknown, unknown, infer SubdocType>
-        ? HydratedSingleSubdocument<BufferToBinary<SubdocType>>
-        : BufferToBinary<T>;
+  export type BufferToBinaryProperty<T> = unknown extends Buffer
+    ? T
+    : T extends Buffer
+      ? mongodb.Binary
+      : T extends Types.DocumentArray<infer ItemType>
+        ? Types.DocumentArray<BufferToBinary<ItemType>>
+        : T extends Types.Subdocument<unknown, unknown, infer SubdocType>
+          ? HydratedSingleSubdocument<BufferToBinary<SubdocType>>
+          : BufferToBinary<T>;
 
   /**
    * Converts any Buffer properties into mongodb.Binary instances, which is what `lean()` returns
    */
-  export type BufferToBinary<T> = T extends Buffer
-    ? mongodb.Binary
-    : T extends Document
-      ? T
-      : T extends TreatAsPrimitives
-        ? T
-        : T extends Record<string, any>
-          ? {
-              [K in keyof T]: BufferToBinaryProperty<T[K]>
-            }
-          : T;
+   export type BufferToBinary<T> = unknown extends Buffer
+     ? T
+     : T extends Buffer
+       ? mongodb.Binary
+       : T extends Document
+         ? T
+         : T extends TreatAsPrimitives
+           ? T
+           : T extends Record<string, any>
+             ? {
+                 [K in keyof T]: BufferToBinaryProperty<T[K]>
+               }
+             : T;
 
   /**
-   * Converts any Buffer properties into { type: 'buffer', data: [1, 2, 3] } format for JSON serialization
-   */
-  export type BufferToJSON<T> = T extends Buffer
-    ? { type: 'buffer', data: number[] }
-    : T extends Document
-      ? T
-      : T extends TreatAsPrimitives
+  * Converts any Buffer properties into { type: 'buffer', data: [1, 2, 3] } format for JSON serialization
+  */
+  export type BufferToJSON<T> = unknown extends Buffer
+    ? T
+    : T extends Buffer
+      ? { type: 'buffer', data: number[] }
+      : T extends Document
         ? T
-        : T extends Record<string, any> ? {
-          [K in keyof T]: T[K] extends Buffer
-            ? { type: 'buffer', data: number[] }
-            : T[K] extends Types.DocumentArray<infer ItemType>
-                ? Types.DocumentArray<BufferToBinary<ItemType>>
-                : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
-                  ? HydratedSingleSubdocument<SubdocType>
-                  : BufferToBinary<T[K]>;
-        } : T;
+        : T extends TreatAsPrimitives
+          ? T
+          : T extends Record<string, any> ? {
+            [K in keyof T]: T[K] extends Buffer
+              ? { type: 'buffer', data: number[] }
+              : T[K] extends Types.DocumentArray<infer ItemType>
+                  ? Types.DocumentArray<BufferToBinary<ItemType>>
+                  : T[K] extends Types.Subdocument<unknown, unknown, infer SubdocType>
+                    ? HydratedSingleSubdocument<SubdocType>
+                    : BufferToBinary<T[K]>;
+          } : T;
 
   /**
    * Converts any ObjectId properties into strings for JSON serialization

package/types/inferschematype.d.ts

@@ -235,13 +235,17 @@ type IsSchemaTypeFromBuiltinClass<T> = T extends (typeof String)
                               ? true
                               : T extends Types.Decimal128
                                 ? true
-                                : T extends Buffer
+                                : T extends NativeDate
                                   ? true
-                                  : T extends NativeDate
+                                  : T extends (typeof Schema.Types.Mixed)
                                     ? true
-                                    : T extends (typeof Schema.Types.Mixed)
+                                    : IfEquals<T, Schema.Types.ObjectId, true, false> extends true
                                       ? true
-                                      : IfEquals<T, Schema.Types.ObjectId, true, false>;
+                                      : unknown extends Buffer
+                                        ? false
+                                        : T extends Buffer
+                                          ? true
+                                          : false;
 
 /**
  * @summary Resolve path type by returning the corresponding type.
@@ -308,14 +312,15 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
                                               IfEquals<PathValueType, BigInt> extends true ? bigint :
                                                 PathValueType extends 'bigint' | 'BigInt' | typeof Schema.Types.BigInt | typeof BigInt ? bigint :
                                                   PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
-                                                    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 'double' | 'Double' | typeof Schema.Types.Double ? Types.Double :
+                                                      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,
   TypeHint>;

package/types/models.d.ts

@@ -308,7 +308,7 @@ declare module 'mongoose' {
     bulkWrite<DocContents = TRawDocType>(
       writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
       options: MongooseBulkWriteOptions & { ordered: false }
-    ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[] } }>;
+    ): Promise<mongodb.BulkWriteResult & { mongoose?: { validationErrors: Error[], results: Array<Error | mongodb.WriteError | null> } }>;
     bulkWrite<DocContents = TRawDocType>(
       writes: Array<AnyBulkWriteOperation<DocContents extends Document ? any : (DocContents extends {} ? DocContents : any)>>,
       options?: MongooseBulkWriteOptions

package/types/populate.d.ts

@@ -39,6 +39,12 @@ declare module 'mongoose' {
     foreignField?: string;
     /** Set to `false` to prevent Mongoose from repopulating paths that are already populated */
     forceRepopulate?: boolean;
+    /**
+     * Set to `true` to execute any populate queries one at a time, as opposed to in parallel.
+     * We recommend setting this option to `true` if using transactions, especially if also populating multiple paths or paths with multiple models.
+     * MongoDB server does **not** support multiple operations in parallel on a single transaction.
+     */
+    ordered?: boolean;
   }
 
   interface PopulateOption {

package/types/types.d.ts

@@ -104,5 +104,7 @@ declare module 'mongoose' {
     }
 
     class UUID extends bson.UUID {}
+
+    class Double extends bson.Double {}
   }
 }