@depup/mongoose 9.3.3-depup.0 → 9.8.0-depup.0

package/types/populate.d.ts

@@ -8,6 +8,50 @@ declare module 'mongoose' {
     RawId extends RefType = (PopulatedType extends { _id?: RefType; } ? NonNullable<PopulatedType['_id']> : Types.ObjectId) | undefined
   > = PopulatedType | RawId;
 
+  const mongoosePopulatedDocumentMarker: unique symbol;
+
+  type ExtractDocumentObjectType<T> = T extends infer ObjectType & Document ? FlatRecord<ObjectType> : T;
+
+  type PopulatePathToRawDocType<T> =
+    T extends Types.DocumentArray<any, infer ItemType>
+      ? PopulatePathToRawDocType<ItemType>[]
+      : T extends Array<infer ItemType>
+        ? PopulatePathToRawDocType<ItemType>[]
+        : T extends Document
+          ? SubdocsToPOJOs<ExtractDocumentObjectType<T>>
+          : T extends Record<string, any>
+            ? { [K in keyof T]: PopulatePathToRawDocType<T[K]> }
+            : T;
+
+  type PopulatedPathsDocumentType<RawDocType, Paths> = UnpackedIntersection<RawDocType, PopulatePathToRawDocType<Paths>>;
+
+  type PopulatedDocumentMarker<
+    PopulatedRawDocType,
+    DepopulatedRawDocType,
+  > = {
+    [mongoosePopulatedDocumentMarker]?: {
+      populated: PopulatedRawDocType,
+      depopulated: DepopulatedRawDocType
+    }
+  };
+
+  type ResolvePopulatedRawDocType<
+    ThisType,
+    FallbackRawDocType,
+    O = never
+  > = ThisType extends PopulatedDocumentMarker<infer PopulatedRawDocType, infer DepopulatedRawDocType>
+    ? O extends { depopulate: true }
+      ? DepopulatedRawDocType
+      : PopulatedRawDocType
+    : FallbackRawDocType;
+
+  type PopulateDocumentResult<
+    Doc,
+    Paths,
+    PopulatedRawDocType,
+    DepopulatedRawDocType = PopulatedRawDocType
+  > = MergeType<Doc, Paths> & PopulatedDocumentMarker<PopulatedRawDocType, DepopulatedRawDocType>;
+
   interface PopulateOptions {
     /** space delimited path(s) to populate */
     path: string;
@@ -17,6 +61,14 @@ declare module 'mongoose' {
     match?: any;
     /** optional model to use for population */
     model?: string | Model<any>;
+    /** by default, Mongoose removes null and undefined values from populated arrays. Use this option to make `populate()` retain `null` and `undefined` array entries. */
+    retainNullValues?: boolean;
+    /** if true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. */
+    getters?: boolean;
+    /** if true, Mongoose will clone populated docs before assigning them, so docs that are populated onto multiple parents don't share 1 copy. */
+    clone?: boolean;
+    /** By default, Mongoose throws a cast error if `localField` and `foreignField` schemas don't line up. If you enable this option, Mongoose will instead filter out any `localField` properties that cannot be casted to `foreignField`'s schema type. */
+    skipInvalidIds?: boolean;
     /** optional query options like sort, limit, etc */
     options?: QueryOptions;
     /** correct limit on populated array */

package/types/query.d.ts

@@ -1,13 +1,13 @@
 declare module 'mongoose' {
   import mongodb = require('mongodb');
 
-  type StringQueryTypeCasting = string | RegExp;
+  type StringQueryTypeCasting<T> = string extends T ? string | RegExp : T | RegExp;
   type ObjectIdQueryTypeCasting = Types.ObjectId | string;
   type DateQueryTypeCasting = string | number | NativeDate;
   type UUIDQueryTypeCasting = Types.UUID | string;
   type BufferQueryCasting = Buffer | mongodb.Binary | number[] | string | { $binary: string | mongodb.Binary };
   type QueryTypeCasting<T> = T extends string
-    ? StringQueryTypeCasting
+    ? StringQueryTypeCasting<T>
     : T extends Types.ObjectId
       ? ObjectIdQueryTypeCasting
       : T extends Types.UUID
@@ -18,22 +18,40 @@ declare module 'mongoose' {
             ? DateQueryTypeCasting
             : T;
 
-  export type ApplyBasicQueryCasting<T> = QueryTypeCasting<T> | QueryTypeCasting<T[]> | (T extends (infer U)[] ? QueryTypeCasting<U> : T) | null;
+  export type ApplyBasicQueryCasting<T> = QueryTypeCasting<T> | QueryTypeCasting<T>[] | (T extends (infer U)[] ? QueryTypeCasting<U> : T) | null;
+
+  type RemoveIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: T[K];
+  };
+
+  type StrictFilterOperators<TValue> = RemoveIndexSignature<mongodb.FilterOperators<TValue>>;
+
+  type StrictCondition<T> = mongodb.AlternativeType<T> | StrictFilterOperators<mongodb.AlternativeType<T>>;
+
+  type _StrictFilter<TSchema> = {
+    [P in keyof TSchema]?: StrictCondition<ApplyBasicQueryCasting<TSchema[P]>>;
+  } & StrictRootFilterOperators<TSchema>;
+
+  type StrictRootFilterOperators<TSchema> = Omit<mongodb.RootFilterOperators<TSchema>, '$and' | '$or' | '$nor'> & {
+    $and?: _StrictFilter<TSchema>[];
+    $or?: _StrictFilter<TSchema>[];
+    $nor?: _StrictFilter<TSchema>[];
+  };
 
   type _QueryFilter<T> = (
-    { [P in keyof T]?: mongodb.Condition<ApplyBasicQueryCasting<T[P]>>; } &
-    mongodb.RootFilterOperators<{ [P in keyof mongodb.WithId<T>]?: ApplyBasicQueryCasting<mongodb.WithId<T>[P]>; }>
+    { [P in keyof T]?: StrictCondition<ApplyBasicQueryCasting<T[P]>>; } &
+    StrictRootFilterOperators<{ [P in keyof mongodb.WithId<T>]?: ApplyBasicQueryCasting<mongodb.WithId<T>[P]>; }>
   );
   type _QueryFilterLooseId<T> = (
-    { [P in keyof T]?: mongodb.Condition<ApplyBasicQueryCasting<T[P]>>; } &
-    mongodb.RootFilterOperators<
-      { [P in keyof T]?: ApplyBasicQueryCasting<T[P]>; } &
-      { _id?: any; }
+    { [P in keyof T]?: StrictCondition<ApplyBasicQueryCasting<T[P]>>; } &
+    StrictRootFilterOperators<
+      { [P in keyof T]?: ApplyBasicQueryCasting<T[P]>; }
     >
   );
   type QueryFilter<T> = IsItRecordAndNotAny<T> extends true ? _QueryFilter<WithLevel1NestedPaths<T>> : _QueryFilterLooseId<Record<string, any>>;
 
   type MongooseBaseQueryOptionKeys =
+    | 'cloneUpdate'
     | 'context'
     | 'middleware'
     | 'multipleCastError'
@@ -91,6 +109,10 @@ declare module 'mongoose' {
     collation?: mongodb.CollationOptions;
     comment?: any;
     context?: string;
+    /**
+     * If `false`, Mongoose will not clone the update before executing the query.
+     */
+    cloneUpdate?: boolean;
     explain?: mongodb.ExplainVerbosityLike;
     fields?: any | string;
     hint?: mongodb.Hint;
@@ -112,6 +134,11 @@ declare module 'mongoose' {
      */
     new?: boolean;
 
+    /**
+     * If `false`, skip applying default schema values to the returned document(s).
+     * @default true
+     */
+    defaults?: boolean;
     overwriteDiscriminatorKey?: boolean;
     /**
      * Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert).
@@ -201,10 +228,10 @@ declare module 'mongoose' {
       ? ResultType
       : ResultType extends (infer U)[]
         ? U extends Document
-          ? HydratedDocument<MergeType<RawDocType, Paths>, TDocOverrides, TQueryHelpers>[]
+          ? PopulateDocumentResult<U, Paths, MergeType<RawDocType, Paths>, RawDocType>[]
           : (MergeType<U, Paths>)[]
         : ResultType extends Document
-          ? HydratedDocument<MergeType<RawDocType, Paths>, TDocOverrides, TQueryHelpers>
+          ? PopulateDocumentResult<ResultType, Paths, MergeType<RawDocType, Paths>, RawDocType>
           : MergeType<ResultType, Paths>
     : MergeType<ResultType, Paths>;
 
@@ -867,7 +894,7 @@ declare module 'mongoose' {
     setQuery(val: QueryFilter<RawDocType> | null): void;
     setQuery(val: Query<any, any> | null): void;
 
-    setUpdate(update: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline): void;
+    setUpdate(update: UpdateQuery<RawDocType> | UpdateWithAggregationPipeline, cloneUpdate?: boolean): void;
 
     /** Specifies an `$size` query condition. When called with one argument, the most recent path passed to `where()` is used. */
     size(path: string, val: number): this;

package/types/schemaoptions.d.ts

@@ -158,6 +158,11 @@ declare module 'mongoose' {
      * [strictQuery](https://mongoosejs.com/docs/guide.html#strictQuery) mode for schemas.
      */
     strictQuery?: boolean | 'throw';
+    /**
+     * May be `false`, `true`, or `'throw'`. Sets the default
+     * [strictRead](https://mongoosejs.com/docs/guide.html#strictRead) mode for schemas.
+     */
+    strictRead?: boolean | 'throw';
     /** Exactly the same as the toObject option but only applies when the document's toJSON method is called. */
     toJSON?: ToObjectOptions<DocType, THydratedDocumentType>;
     /**

package/types/schematypes.d.ts

@@ -104,6 +104,13 @@ declare module 'mongoose' {
       | [boolean, string]
       | [(this: THydratedDocumentType) => boolean, string];
 
+    /**
+     * Controls whether this path may be set to `null`. By default, Mongoose allows
+     * `null` for non-required paths. Set `allowNull: false` to allow `undefined`
+     * but disallow `null`.
+     */
+    allowNull?: boolean;
+
     /**
      * The default value for this path. If a function, Mongoose executes the function
      * and uses the return value as the default.
@@ -355,6 +362,9 @@ declare module 'mongoose' {
      */
     required(required: boolean, message?: string): this;
 
+    /** Adds or removes a validator that disallows `null` without making this path required. */
+    allowNull(allowNull: boolean): this;
+
     /** If the SchemaType is a subdocument or document array, this is the schema of that subdocument */
     schema?: Schema<any>;
 

package/types/tracing.d.ts

@@ -0,0 +1,10 @@
+declare module 'mongoose' {
+  interface TracingContext {
+    operation: string;
+    collection: string;
+    database: string;
+    serverAddress: string;
+    serverPort: number;
+    args: Record<string, any>;
+  }
+}

package/types/utility.d.ts

@@ -98,10 +98,10 @@ declare module 'mongoose' {
   type UnpackedIntersection<T, U> = T extends null
     ? null
     : T extends (infer A)[]
-    ? (Omit<A, keyof U> & U)[]
+    ? (A extends any ? (Omit<A, keyof U> & U) : never)[]
     : keyof U extends never
     ? T
-    : Omit<T, keyof U> & U;
+    : T extends any ? (Omit<T, keyof U> & U) : never;
 
   type MergeType<A, B> = A extends unknown ? Omit<A, keyof B> & B : never;
 
@@ -161,6 +161,15 @@ declare module 'mongoose' {
       : T[K];
   };
 
+  type OmitThisParameterIfFunction<T> = T extends (...args: any[]) => any ? OmitThisParameter<T> : T;
+
+  // Strip explicit `this` parameter from methods in schema type options. The `this` parameter
+  // is just for type-checking the function body. Keeping the explicit 'this' typing can cause
+  // compiler errors on the method calls, so remove it for the hydrated document definition.
+  type HydratedDocumentOverrides<T> = {
+    [K in keyof T]: OmitThisParameterIfFunction<T[K]>;
+  };
+
   /**
    * @summary Adds timestamp fields to a type
    * @description Adds createdAt and updatedAt fields of type Date, or custom timestamp fields if specified

package/lib/helpers/createJSONSchemaTypeDefinition.js

@@ -1,24 +0,0 @@
-'use strict';
-
-/**
- * Handles creating `{ type: 'object' }` vs `{ bsonType: 'object' }` vs `{ bsonType: ['object', 'null'] }`
- *
- * @param {string} type
- * @param {string} bsonType
- * @param {boolean} useBsonType
- * @param {boolean} isRequired
- */
-
-module.exports = function createJSONSchemaTypeArray(type, bsonType, useBsonType, isRequired) {
-  if (useBsonType) {
-    if (isRequired) {
-      return { bsonType };
-    }
-    return { bsonType: [bsonType, 'null'] };
-  } else {
-    if (isRequired) {
-      return { type };
-    }
-    return { type: [type, 'null'] };
-  }
-};