mongoose 8.20.0 → 9.0.0-rc0

package/types/utility.d.ts

@@ -4,57 +4,71 @@ declare module 'mongoose' {
     : ELSETYPE;
   type IfUnknown<IFTYPE, THENTYPE> = unknown extends IFTYPE ? THENTYPE : IFTYPE;
 
-  type WithLevel1NestedPaths<T, K extends keyof T = keyof T> = {
+  type IsNotNever<T> = [T] extends [never] ? false : true;
+  type IsAny<T> = 0 extends 1 & T ? true : false;
+
+  type WithLevel1NestedPaths<T, K extends keyof T = keyof T> = IsItRecordAndNotAny<T> extends true ? {
     [P in K | NestedPaths<Required<T>, K>]: P extends K
-      ? // Handle top-level paths
-        // First, drill into documents so we don't end up surfacing `$assertPopulated`, etc.
-        Extract<NonNullable<T[P]>, Document> extends never
-        ? // If not a document, then return the type. Otherwise, get the DocType.
-          NonNullable<T[P]>
-        : Extract<NonNullable<T[P]>, Document> extends Document<
-            any,
-            any,
-            infer DocType,
-            any
-          >
-        ? DocType
-        : never
-      : // Handle nested paths
-      P extends `${infer Key}.${infer Rest}`
-      ? Key extends keyof T
-        ? T[Key] extends (infer U)[]
-          ? Rest extends keyof NonNullable<U>
-            ? NonNullable<U>[Rest]
-            : never
-          : Rest extends keyof NonNullable<T[Key]>
-          ? NonNullable<T[Key]>[Rest]
+      // Handle top-level paths
+      // First, drill into documents so we don't end up surfacing `$assertPopulated`, etc.
+      ? Extract<NonNullable<T[P]>, Document> extends never
+        // If not a document, then return the type. Otherwise, get the DocType.
+        ? NonNullable<T[P]>
+        : Extract<NonNullable<T[P]>, Document> extends Document<any, any, infer DocType, any>
+          ? DocType
           : never
-        : never
-      : never;
-  };
-
-  type NestedPaths<T, K extends keyof T> = K extends string
-    ? T[K] extends TreatAsPrimitives
-      ? never
-      : Extract<NonNullable<T[K]>, Document> extends never
-      ? T[K] extends Array<infer U>
-        ? U extends Record<string, any>
-          ? `${K}.${keyof NonNullable<U> & string}`
+      // Handle nested paths
+      : P extends `${infer Key}.${infer Rest}`
+        ? Key extends keyof T
+          ? NonNullable<T[Key]> extends (infer U)[]
+            ? NonNullable<T[Key]> extends Types.DocumentArray<infer TRawDocType>
+              ? Rest extends keyof NonNullable<TRawDocType>
+                ? NonNullable<TRawDocType>[Rest]
+                : never
+            : Rest extends keyof NonNullable<U>
+              ? NonNullable<U>[Rest]
+              : never
+            : Rest extends keyof NonNullable<T[Key]>
+              ? NonNullable<T[Key]>[Rest]
+              : never
           : never
-        : T[K] extends Record<string, any> | null | undefined
-        ? `${K}.${keyof NonNullable<T[K]> & string}`
-        : never
-      : Extract<NonNullable<T[K]>, Document> extends Document<
-          any,
-          any,
-          infer DocType,
-          any
-        >
-      ? DocType extends Record<string, any>
-        ? `${K}.${keyof NonNullable<DocType> & string}`
-        : never
-      : never
-    : never;
+        : never;
+  } : T;
+
+  type HasStringIndex<T> =
+    string extends Extract<keyof T, string> ? true : false;
+
+  type SafeObjectKeys<T> =
+    HasStringIndex<T> extends true ? never : Extract<keyof T, string>;
+
+  type NestedPaths<T, K extends keyof T> =
+    K extends string
+      ? T[K] extends TreatAsPrimitives
+        ? never
+        : Extract<NonNullable<T[K]>, Document> extends never
+          ? NonNullable<T[K]> extends Array<infer U>
+            ? NonNullable<T[K]> extends Types.DocumentArray<infer TRawDocType>
+              ? SafeObjectKeys<NonNullable<TRawDocType>> extends never
+                ? never
+                : `${K}.${SafeObjectKeys<NonNullable<TRawDocType>>}`
+              : NonNullable<U> extends Record<string, any>
+                ? SafeObjectKeys<NonNullable<U>> extends never
+                  ? never
+                  : `${K}.${SafeObjectKeys<NonNullable<U>>}`
+                : never
+            : NonNullable<T[K]> extends object
+              ? SafeObjectKeys<NonNullable<T[K]>> extends never
+                ? never
+                : `${K}.${SafeObjectKeys<NonNullable<T[K]>>}`
+              : never
+          : Extract<NonNullable<T[K]>, Document> extends Document<any, any, infer DocType, any>
+            ? DocType extends object
+              ? SafeObjectKeys<NonNullable<DocType>> extends never
+                ? never
+                : `${K}.${SafeObjectKeys<NonNullable<DocType>>}`
+              : never
+            : never
+      : never;
 
   type WithoutUndefined<T> = T extends undefined ? never : T;
 
@@ -75,6 +89,12 @@ declare module 'mongoose' {
     ? U
     : T;
 
+  type DeepPartial<T> =
+    T extends TreatAsPrimitives ? T :
+    T extends Array<infer U> ? DeepPartial<U>[] :
+    T extends Record<string, any> ? { [K in keyof T]?: DeepPartial<T[K]> } :
+    T;
+
   type UnpackedIntersection<T, U> = T extends null
     ? null
     : T extends (infer A)[]

package/types/validation.d.ts

@@ -1,11 +1,10 @@
 declare module 'mongoose' {
-
-  type SchemaValidator<T, EnforcedDocType, THydratedDocumentType> = RegExp
-    | [RegExp, string]
-    | Function
-    | [Function, string]
-    | ValidateOpts<T, THydratedDocumentType>
-    | ValidateOpts<T, THydratedDocumentType>[];
+  type SchemaValidator<T, THydratedDocumentType> = RegExp |
+    [RegExp, string] |
+    Function |
+    [Function, string] |
+    ValidateOpts<T, THydratedDocumentType> |
+    ValidateOpts<T, THydratedDocumentType>[];
 
   interface ValidatorProps {
     path: string;
@@ -18,18 +17,23 @@ declare module 'mongoose' {
     (props: ValidatorProps): string;
   }
 
-  type ValidateFn<T, EnforcedDocType> =
-    (this: EnforcedDocType, value: any, props?: ValidatorProps & Record<string, any>) => boolean;
+  type ValidateFn<T, THydratedDocumentType> = (
+    this: THydratedDocumentType | Query<unknown, THydratedDocumentType>,
+    value: any,
+    props?: ValidatorProps & Record<string, any>
+  ) => boolean;
 
-  type AsyncValidateFn<T, EnforcedDocType> =
-    (this: EnforcedDocType, value: any, props?: ValidatorProps & Record<string, any>) => Promise<boolean>;
+  type AsyncValidateFn<T, THydratedDocumentType> = (
+    this: THydratedDocumentType | Query<unknown, THydratedDocumentType>,
+    value: any,
+    props?: ValidatorProps & Record<string, any>
+  ) => Promise<boolean>;
 
-  interface ValidateOpts<T, EnforcedDocType> {
+  interface ValidateOpts<T, THydratedDocumentType> {
     msg?: string;
     message?: string | ValidatorMessageFn;
     type?: string;
-    validator: ValidateFn<T, EnforcedDocType>
-    | AsyncValidateFn<T, EnforcedDocType>;
+    validator: ValidateFn<T, THydratedDocumentType> | AsyncValidateFn<T, THydratedDocumentType>;
     propsParameter?: boolean;
   }
 }

package/browser.js

@@ -1,8 +0,0 @@
-/**
- * Export lib/mongoose
- *
- */
-
-'use strict';
-
-module.exports = require('./lib/browser');