mongoose 8.2.4 → 8.3.1

package/types/index.d.ts

@@ -27,6 +27,7 @@
 declare class NativeDate extends global.Date { }
 
 declare module 'mongoose' {
+  import Kareem = require('kareem');
   import events = require('events');
   import mongodb = require('mongodb');
   import mongoose = require('mongoose');
@@ -397,7 +398,6 @@ declare module 'mongoose' {
     ): this;
     // this = Document
     pre<T = THydratedDocumentType>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
-    pre<T = THydratedDocumentType>(method: 'save', options: SchemaPreOptions, fn: PreSaveMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(method: MongooseDistinctDocumentMiddleware|MongooseDistinctDocumentMiddleware[], options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = THydratedDocumentType>(
@@ -415,7 +415,6 @@ declare module 'mongoose' {
     pre<T = THydratedDocumentType|Query<any, any>>(method: MongooseQueryOrDocumentMiddleware | MongooseQueryOrDocumentMiddleware[] | RegExp, fn: PreMiddlewareFunction<T>): this;
     // method aggregate
     pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PreMiddlewareFunction<T>): this;
-    pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     /* method insertMany */
     pre<T = TModelType>(
       method: 'insertMany' | RegExp,
@@ -426,16 +425,6 @@ declare module 'mongoose' {
         options?: InsertManyOptions & { lean?: boolean }
       ) => void | Promise<void>
     ): this;
-    pre<T = TModelType>(
-      method: 'insertMany' | RegExp,
-      options: SchemaPreOptions,
-      fn: (
-        this: T,
-        next: (err?: CallbackError) => void,
-        docs: any | Array<any>,
-        options?: InsertManyOptions & { lean?: boolean }
-      ) => void | Promise<void>
-    ): this;
     /* method bulkWrite */
     pre<T = TModelType>(
       method: 'bulkWrite' | RegExp,
@@ -446,16 +435,6 @@ declare module 'mongoose' {
         options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
       ) => void | Promise<void>
     ): this;
-    pre<T = TModelType>(
-      method: 'bulkWrite' | RegExp,
-      options: SchemaPreOptions,
-      fn: (
-        this: T,
-        next: (err?: CallbackError) => void,
-        ops: Array<mongodb.AnyBulkWriteOperation<any> & MongooseBulkWritePerWriteOptions>,
-        options?: mongodb.BulkWriteOptions & MongooseBulkWriteOptions
-      ) => void | Promise<void>
-    ): this;
     /* method createCollection */
     pre<T = TModelType>(
       method: 'createCollection' | RegExp,
@@ -465,15 +444,6 @@ declare module 'mongoose' {
         options?: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'>
       ) => void | Promise<void>
     ): this;
-    pre<T = TModelType>(
-      method: 'createCollection' | RegExp,
-      options: SchemaPreOptions,
-      fn: (
-        this: T,
-        next: (err?: CallbackError) => void,
-        options?: mongodb.CreateCollectionOptions & Pick<SchemaOptions, 'expires'>
-      ) => void | Promise<void>
-    ): this;
 
     /** Object of currently defined query helpers on this schema. */
     query: TQueryHelpers;
@@ -722,5 +692,9 @@ declare module 'mongoose' {
   /* for ts-mongoose */
   export class mquery { }
 
+  export function overwriteMiddlewareResult(val: any): Kareem.OverwriteMiddlewareResult;
+
+  export function skipMiddlewareFunction(val: any): Kareem.SkipWrappedFunction;
+
   export default mongoose;
 }

package/types/middlewares.d.ts

@@ -1,4 +1,5 @@
 declare module 'mongoose' {
+  import Kareem = require('kareem');
 
   type MongooseQueryAndDocumentMiddleware = 'updateOne' | 'deleteOne';
 
@@ -37,13 +38,13 @@ declare module 'mongoose' {
     this: ThisType,
     next: CallbackWithoutResultAndOptionalError,
     opts?: Record<string, any>
-  ) => void | Promise<void>;
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
   type PreSaveMiddlewareFunction<ThisType = any> = (
     this: ThisType,
     next: CallbackWithoutResultAndOptionalError,
     opts: SaveOptions
-  ) => void | Promise<void>;
-  type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
+  ) => void | Promise<void> | Kareem.SkipWrappedFunction;
+  type PostMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, res: ResType, next: CallbackWithoutResultAndOptionalError) => void | Promise<void> | Kareem.OverwriteMiddlewareResult;
   type ErrorHandlingMiddlewareFunction<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType, next: CallbackWithoutResultAndOptionalError) => void;
-  type ErrorHandlingMiddlewareWithOption<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType | null, next: CallbackWithoutResultAndOptionalError) => void | Promise<void>;
+  type ErrorHandlingMiddlewareWithOption<ThisType = any, ResType = any> = (this: ThisType, err: NativeError, res: ResType | null, next: CallbackWithoutResultAndOptionalError) => void | Promise<void> | Kareem.OverwriteMiddlewareResult;
 }

package/types/query.d.ts

@@ -741,7 +741,10 @@ declare module 'mongoose' {
     slice(val: number | Array<number>): this;
 
     /** Sets the sort order. If an object is passed, values allowed are `asc`, `desc`, `ascending`, `descending`, `1`, and `-1`. */
-    sort(arg?: string | { [key: string]: SortOrder | { $meta: any } } | [string, SortOrder][] | undefined | null): this;
+    sort(
+      arg?: string | { [key: string]: SortOrder | { $meta: any } } | [string, SortOrder][] | undefined | null,
+      options?: { override?: boolean }
+    ): this;
 
     /** Sets the tailable option (for use with capped collections). */
     tailable(bool?: boolean, opts?: {

package/types/schematypes.d.ts

@@ -192,10 +192,15 @@ declare module 'mongoose' {
     [other: string]: any;
   }
 
-  interface Validator {
-    message?: string; type?: string; validator?: Function
+  interface Validator<DocType = any> {
+    message?: string | ((props: ValidatorProps) => string);
+    type?: string;
+    validator?: ValidatorFunction<DocType>;
+    reason?: Error;
   }
 
+  type ValidatorFunction<DocType = any> = (this: DocType, value: any, validatorProperties?: Validator) => any;
+
   class SchemaType<T = any, DocType = any> {
     /** SchemaType constructor */
     constructor(path: string, options?: AnyObject, instance?: string);
@@ -281,7 +286,10 @@ declare module 'mongoose' {
     validators: Validator[];
 
     /** Adds validator(s) for this document path. */
-    validate(obj: RegExp | ((this: DocType, value: any, validatorProperties?: Validator) => any), errorMsg?: string, type?: string): this;
+    validate(obj: RegExp | ValidatorFunction<DocType> | Validator<DocType>, errorMsg?: string, type?: string): this;
+
+    /** Adds multiple validators for this document path. */
+    validateAll(validators: Array<RegExp | ValidatorFunction<DocType> | Validator<DocType>>): this;
 
     /** Default options for this SchemaType */
     defaultOptions?: Record<string, any>;

package/types/validation.d.ts

@@ -6,6 +6,7 @@ declare module 'mongoose' {
     path: string;
     fullPath: string;
     value: any;
+    reason?: Error;
   }
 
   interface ValidatorMessageFn {