@depup/mongoose 9.1.3-depup.0

package/types/types.d.ts

@@ -0,0 +1,109 @@
+
+declare module 'mongoose' {
+  import mongodb = require('mongodb');
+
+  class NativeBuffer extends Buffer {}
+
+  namespace Types {
+    class Array<T> extends global.Array<T> {
+      /** Pops the array atomically at most one time per document `save()`. */
+      $pop(): T;
+
+      /** Atomically shifts the array at most one time per document `save()`. */
+      $shift(): T;
+
+      /** Adds values to the array if not already present. */
+      addToSet(...args: any[]): any[];
+
+      isMongooseArray: true;
+
+      /** Pushes items to the array non-atomically. */
+      nonAtomicPush(...args: any[]): number;
+
+      /** Wraps [`Array#push`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking. */
+      push(...args: any[]): number;
+
+      /**
+       * Pulls items from the array atomically. Equality is determined by casting
+       * the provided value to an embedded document and comparing using
+       * [the `Document.equals()` function.](./api/document.html#document_Document-equals)
+       */
+      pull(...args: any[]): this;
+
+      /**
+       * Alias of [pull](#mongoosearray_MongooseArray-pull)
+       */
+      remove(...args: any[]): this;
+
+      /** Sets the casted `val` at index `i` and marks the array modified. */
+      set(index: number, val: T): this;
+
+      /** Atomically shifts the array at most one time per document `save()`. */
+      shift(): T;
+
+      /** Returns a native js Array. */
+      toObject(options?: ToObjectOptions): any;
+      toObject<T>(options?: ToObjectOptions<T>): T;
+
+      /** Wraps [`Array#unshift`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/unshift) with proper change tracking. */
+      unshift(...args: any[]): number;
+    }
+
+    class Buffer extends NativeBuffer {
+      /** Sets the subtype option and marks the buffer modified. */
+      subtype(subtype: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 128 | ToObjectOptions): void;
+
+      /** Converts this buffer to its Binary type representation. */
+      toObject(subtype?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 128): mongodb.Binary;
+    }
+
+    class Decimal128 extends mongodb.Decimal128 { }
+
+    class DocumentArray<T, THydratedDocumentType extends Types.Subdocument<any, any, any> = Types.Subdocument<InferId<T>, unknown, T> & T> extends Types.Array<THydratedDocumentType> {
+      /** DocumentArray constructor */
+      constructor(values: AnyObject[]);
+
+      isMongooseDocumentArray: true;
+
+      /** Creates a subdocument casted to this schema. */
+      create(obj: any): THydratedDocumentType;
+
+      /** Searches array items for the first document with a matching _id. */
+      id(id: ObjectId | string | number | Buffer): THydratedDocumentType | null;
+
+      push(...args: (AnyKeys<T> & AnyObject)[]): number;
+
+      splice(start: number, deleteCount?: number, ...args: (AnyKeys<T> & AnyObject)[]): THydratedDocumentType[];
+    }
+
+    class Map<V> extends global.Map<string, V> {
+      /** Converts a Mongoose map into a vanilla JavaScript map. */
+      toObject(options?: ToObjectOptions & { flattenMaps?: boolean }): any;
+    }
+
+    class ObjectId extends mongodb.ObjectId {
+    }
+
+    class Subdocument<IdType = any, TQueryHelpers = any, DocType = any> extends Document<IdType, TQueryHelpers, DocType> {
+      $isSingleNested: true;
+
+      /** Returns the top level document of this sub-document. */
+      ownerDocument(): Document;
+
+      /** Returns this sub-documents parent document. */
+      parent(): Document;
+
+      /** Returns this sub-documents parent document. */
+      $parent(): Document;
+    }
+
+    class ArraySubdocument<IdType = any, TQueryHelpers = unknown, DocType = unknown> extends Subdocument<IdType, TQueryHelpers, DocType> {
+      /** Returns this sub-documents parent array. */
+      parentArray(): Types.DocumentArray<unknown>;
+    }
+
+    class UUID extends mongodb.UUID {}
+
+    class Double extends mongodb.Double {}
+  }
+}

package/types/utility.d.ts

@@ -0,0 +1,175 @@
+declare module 'mongoose' {
+  type IfAny<IFTYPE, THENTYPE, ELSETYPE = IFTYPE> = 0 extends 1 & IFTYPE
+    ? THENTYPE
+    : ELSETYPE;
+  type IsUnknown<T> = unknown extends T ? true : false;
+
+  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 | Exclude<NonNullable<T[P]>, Document>
+          : never
+      // 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
+        : 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;
+
+  /**
+   * @summary Removes keys from a type
+   * @description It helps to exclude keys from a type
+   * @param {T} T A generic type to be checked.
+   * @param {K} K Keys from T that are to be excluded from the generic type
+   * @returns T with the keys in K excluded
+   */
+  type ExcludeKeys<T, K extends keyof T> = {
+    [P in keyof T as P extends K ? never : P]: T[P];
+  };
+
+  type Unpacked<T> = T extends (infer U)[]
+    ? U
+    : T extends ReadonlyArray<infer U>
+    ? 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)[]
+    ? (Omit<A, keyof U> & U)[]
+    : keyof U extends never
+    ? T
+    : Omit<T, keyof U> & U;
+
+  type MergeType<A, B> = Omit<A, keyof B> & B;
+
+  /**
+   * @summary Converts Unions to one record "object".
+   * @description It makes intellisense dialog box easier to read as a single object instead of showing that in multiple object unions.
+   * @param {T} T The type to be converted.
+   */
+  type FlatRecord<T> = { [K in keyof T]: T[K] };
+
+  /** Force an operation like `{ a: 0 } & { b: 1 }` to be computed so that it displays `{ a: 0; b: 1 }`. */
+  export type Show<t> = { [k in keyof t]: t[k] } & unknown;
+
+  /**
+   * @summary Checks if a type is "Record" or "any".
+   * @description It Helps to check if user has provided schema type "EnforcedDocType"
+   * @param {T} T A generic type to be checked.
+   * @returns true if {@link T} is Record OR false if {@link T} is of any type.
+   */
+  type IsItRecordAndNotAny<T> = IfEquals<
+    T,
+    any,
+    false,
+    T extends Record<any, any> ? true : false
+  >;
+
+  /**
+   * @summary Checks if two types are identical.
+   * @param {T} T The first type to be compared with {@link U}.
+   * @param {U} U The seconde type to be compared with {@link T}.
+   * @param {Y} Y A type to be returned if {@link T} &  {@link U} are identical.
+   * @param {N} N A type to be returned if {@link T} &  {@link U} are not identical.
+   */
+  type IfEquals<T, U, Y = true, N = false> = (<G>() => G extends T
+    ? 1
+    : 0) extends <G>() => G extends U ? 1 : 0
+    ? Y
+    : N;
+
+  /**
+   * @summary Extracts 'this' parameter from a function, if it exists. Otherwise, returns fallback.
+   * @param {T} T Function type to extract 'this' parameter from.
+   * @param {F} F Fallback type to return if 'this' parameter does not exist.
+   */
+  type ThisParameter<T, F> = T extends { (this: infer This, ...args: never): void } ? This : F;
+
+  /**
+   * @summary Decorates all functions in an object with 'this' parameter.
+   * @param {T} T Object with functions as values to add 'D' parameter to as 'this'. {@link D}
+   * @param {D} D The type to be added as 'this' parameter to all functions in {@link T}.
+   */
+  type AddThisParameter<T, D> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R
+      ? IsUnknown<ThisParameter<T[K], unknown>> extends true
+        ? (this: D, ...args: A) => R
+        : T[K]
+      : T[K];
+  };
+
+  /**
+   * @summary Adds timestamp fields to a type
+   * @description Adds createdAt and updatedAt fields of type Date, or custom timestamp fields if specified
+   * @param {T} T The type to add timestamp fields to
+   * @param {P} P Optional SchemaTimestampsConfig or boolean to customize timestamp field names
+   * @returns T with timestamp fields added
+   */
+  export type WithTimestamps<
+    T,
+    P extends SchemaTimestampsConfig | boolean = true
+  > = ResolveTimestamps<T, { timestamps: P }>;
+}

package/types/validation.d.ts

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

package/types/virtuals.d.ts

@@ -0,0 +1,14 @@
+declare module 'mongoose' {
+    type VirtualPathFunctions<DocType = {}, PathValueType = unknown, TInstanceMethods = {}> = {
+      get?: TVirtualPathFN<DocType, PathValueType, TInstanceMethods, PathValueType>;
+      set?: TVirtualPathFN<DocType, PathValueType, TInstanceMethods, void>;
+      options?: VirtualTypeOptions<HydratedDocument<DocType, TInstanceMethods>, DocType>;
+    };
+
+  type TVirtualPathFN<DocType = {}, PathType = unknown, TInstanceMethods = {}, TReturn = unknown> =
+    <T = HydratedDocument<DocType, TInstanceMethods>>(this: Document<any, any, DocType> & DocType, value: PathType, virtual: VirtualType<T>, doc: Document<any, any, DocType> & DocType) => TReturn;
+
+  type SchemaOptionsVirtualsPropertyType<DocType = any, VirtualPaths = Record<any, unknown>, TInstanceMethods = {}> = {
+    [K in keyof VirtualPaths]: VirtualPathFunctions<IsItRecordAndNotAny<DocType> extends true ? DocType : any, VirtualPaths[K], TInstanceMethods>
+  };
+}