Create separate generic for schema definition

test/types/docArray.test.ts

@@ -16,6 +16,9 @@ async function gh10293() {
   });
 
   const TestModel = model('gh10293TestModel', testSchema);
+  const doc = new TestModel();
+  expectType<string>(doc.name);
+  expectType<string[][]>(doc.arrayOfArray);
 
   testSchema.methods.getArrayOfArray = function(this: InstanceType<typeof TestModel>): string[][] { // <-- function to return Array of Array
     const test = this.toObject();
@@ -45,7 +48,7 @@ function gh13087() {
         required: true,
         type: [Number] // [longitude, latitude]
       }
-    },
+    } as const,
     { _id: false }
   );
 

test/types/document.test.ts

@@ -230,6 +230,12 @@ async function gh11960() {
 
   type ParentModelType = Model<Parent, {}, {}, {}, ParentDocument>;
 
+  const schemaDefinition = {
+    username: { type: String },
+    map: { type: Map, of: String },
+    nested: { type: NestedSchema },
+    nestedArray: [{ type: NestedSchema }]
+  } as const;
   const ParentSchema = new Schema<
   Parent,
   ParentModelType,
@@ -238,6 +244,7 @@ async function gh11960() {
   {},
   {},
   DefaultSchemaOptions,
+  typeof schemaDefinition,
   Parent,
   ParentDocument
   >({

test/types/querycursor.test.ts

@@ -1,7 +1,7 @@
 import { Schema, model, Model, Types } from 'mongoose';
 import { expectType } from 'tsd';
 
-const schema = new Schema({ name: { type: 'String' } });
+const schema = new Schema({ name: { type: 'String' as const } });
 
 const Test = model('Test', schema);
 
@@ -20,3 +20,5 @@ Test.find().cursor().
     expectType<number>(i);
   }).
   then(() => console.log('Done!'));
+
+expectType<{ name: { type: 'String' } }>(schema.obj);

test/types/schema.test.ts

@@ -463,7 +463,7 @@ export function autoTypedSchema() {
     decimal1: Schema.Types.Decimal128,
     decimal2: 'Decimal128',
     decimal3: 'decimal128'
-  });
+  } as const);
 
   type InferredTestSchemaType = InferSchemaType<typeof TestSchema>;
 
@@ -483,7 +483,7 @@ export function autoTypedSchema() {
   const AutoTypedSchema = new Schema({
     userName: {
       type: String,
-      required: [true, 'userName is required']
+      required: [true, 'userName is required'] as [true, string]
     },
     description: String,
     nested: new Schema({
@@ -519,7 +519,7 @@ export function autoTypedSchema() {
         })
       ]
     }
-  }, {
+  } as const, {
     statics: {
       staticFn() {
         expectType<Model<InferSchemaType<typeof AutoTypedSchema>>>(this);
@@ -558,8 +558,8 @@ export type AutoTypedSchemaType = {
       date: Date;
       messages?: number;
     }>
-  }
-  , statics: {
+  },
+  statics: {
     staticFn: () => 'Returned from staticFn'
   },
   methods: {
@@ -596,17 +596,24 @@ function gh11828() {
     }
   };
 
-  new Schema<IUser>({
+  const schema = new Schema<IUser>({
     name: { type: String, default: () => 'Hafez' },
     age: { type: Number, default: () => 27 },
     bornAt: { type: Date, default: () => new Date() },
     isActive: {
       type: Boolean,
-      default(): boolean {
+      default(this: HydratedDocument<IUser>): boolean {
         return this.name === 'Hafez';
       }
     }
   });
+
+  const UserModel = model<IUser>('User', schema);
+  const doc = new UserModel();
+  expectType<string>(doc.name);
+  expectType<number>(doc.age);
+  expectType<Date>(doc.bornAt);
+  expectType<boolean>(doc.isActive);
 }
 
 function gh11997() {
@@ -760,7 +767,7 @@ function pluginOptions() {
   }
 
   const schema = new Schema({});
-  expectType<Schema<any>>(schema.plugin(pluginFunction)); // test that chaining would be possible
+  expectAssignable<Schema<any>>(schema.plugin(pluginFunction)); // test that chaining would be possible
 
   // could not add strict tests that the parameters are inferred correctly, because i dont know how this would be done in tsd
 
@@ -1008,7 +1015,7 @@ function gh12869() {
   const dbExample = new Schema(
     {
       active: { type: String, enum: ['foo', 'bar'], required: true }
-    }
+    } as const
   );
 
   type Example = InferSchemaType<typeof dbExample>;
@@ -1031,7 +1038,7 @@ function gh12882() {
   const arrNum = new Schema({
     fooArray: {
       type: [{
-        type: 'Number',
+        type: 'Number' as const,
         required: true
       }],
       required: true
@@ -1154,6 +1161,23 @@ function gh13514() {
   const str: string = doc.email;
 }
 
+function defaultFn() {
+  const schema = new Schema({
+    name: String,
+    email: {
+      type: String,
+      // Requires `this: any` even in 7.0.
+      default(this: any) {
+        return this.name + '@test.com';
+      }
+    }
+  });
+  const Test = model('Test', schema);
+
+  const doc = new Test({ name: 'john' });
+  const str: string = doc.email;
+}
+
 function gh13633() {
   const schema = new Schema({ name: String });
 
@@ -1223,10 +1247,22 @@ async function gh13797() {
   interface IUser {
     name: string;
   }
-  new Schema<IUser>({ name: { type: String, required: function() {
-    expectType<IUser>(this); return true;
-  } } });
-  new Schema<IUser>({ name: { type: String, default: function() {
-    expectType<IUser>(this); return '';
-  } } });
+  new Schema<IUser>({
+    name: {
+      type: String,
+      required: function() {
+        expectType<IUser>(this);
+        return true;
+      }
+    }
+  });
+  new Schema<IUser>({
+    name: {
+      type: String,
+      default: function() {
+        expectType<IUser>(this);
+        return '';
+      }
+    }
+  });
 }

test/types/virtuals.test.ts

@@ -95,14 +95,15 @@ async function autoTypedVirtuals() {
   const testSchema = new Schema({
     email: {
       type: String,
-      required: [true, 'email is required']
+      required: [true, 'email is required'] as [true, string]
     }
   }, {
     virtuals: {
       domain: {
         get() {
           expectType<Document<any, any, { email: string }> & AutoTypedSchemaType>(this);
-          return this.email.slice(this.email.indexOf('@') + 1);
+          const email = this.email;
+          return email.slice(email.indexOf('@') + 1);
         },
         set() {
           expectType<Document<any, any, AutoTypedSchemaType> & AutoTypedSchemaType>(this);

types/index.d.ts

@@ -79,16 +79,16 @@ declare module 'mongoose' {
     collection?: string,
     options?: CompileModelOptions
   ): Model<
-  InferSchemaType<TSchema>,
-  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
-  ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
-  ObtainSchemaGeneric<TSchema, 'TVirtuals'>,
-  HydratedDocument<
-  InferSchemaType<TSchema>,
-  ObtainSchemaGeneric<TSchema, 'TVirtuals'> & ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
-  ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>
-  >,
-  TSchema
+    InferSchemaType<TSchema>,
+    ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>,
+    ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
+    ObtainSchemaGeneric<TSchema, 'TVirtuals'>,
+    HydratedDocument<
+      InferSchemaType<TSchema>,
+      ObtainSchemaGeneric<TSchema, 'TVirtuals'> & ObtainSchemaGeneric<TSchema, 'TInstanceMethods'>,
+      ObtainSchemaGeneric<TSchema, 'TQueryHelpers'>
+    >,
+    TSchema
   > & ObtainSchemaGeneric<TSchema, 'TStaticMethods'>;
 
   export function model<T>(name: string, schema?: Schema<T, any, any> | Schema<T & Document, any, any>, collection?: string, options?: CompileModelOptions): Model<T>;
@@ -223,11 +223,12 @@ declare module 'mongoose' {
     TVirtuals = {},
     TStaticMethods = {},
     TSchemaOptions = DefaultSchemaOptions,
+    TSchemaDefinition = any,
     DocType extends ApplySchemaOptions<
-      ObtainDocumentType<DocType, EnforcedDocType, ResolveSchemaOptions<TSchemaOptions>>,
+      ObtainDocumentType<TSchemaDefinition, EnforcedDocType, ResolveSchemaOptions<TSchemaOptions>>,
       ResolveSchemaOptions<TSchemaOptions>
     > = ApplySchemaOptions<
-      ObtainDocumentType<any, EnforcedDocType, ResolveSchemaOptions<TSchemaOptions>>,
+      ObtainDocumentType<TSchemaDefinition, EnforcedDocType, ResolveSchemaOptions<TSchemaOptions>>,
       ResolveSchemaOptions<TSchemaOptions>
     >,
     THydratedDocumentType = HydratedDocument<DocType, TVirtuals & TInstanceMethods>
@@ -236,7 +237,7 @@ declare module 'mongoose' {
     /**
      * Create a new schema
      */
-    constructor(definition?: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>, EnforcedDocType> | DocType, options?: SchemaOptions<DocType, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
+    constructor(definition?: TSchemaDefinition, options?: SchemaOptions<DocType, TInstanceMethods, TQueryHelpers, TStaticMethods, TVirtuals, THydratedDocumentType> | ResolveSchemaOptions<TSchemaOptions>);
 
     /** Adds key path / schema type pairs to this schema. */
     add(obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>> | Schema, prefix?: string): this;
@@ -300,7 +301,7 @@ declare module 'mongoose' {
     methods: { [F in keyof TInstanceMethods]: TInstanceMethods[F] } & AnyObject;
 
     /** The original object passed to the schema constructor */
-    obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>, EnforcedDocType>;
+    obj: TSchemaDefinition;
 
     /** Gets/sets schema paths. */
     path<ResultType extends SchemaType = SchemaType<any, THydratedDocumentType>>(path: string): ResultType;

types/inferschematype.d.ts

@@ -46,8 +46,8 @@ declare module 'mongoose' {
    * @param {TSchema} TSchema A generic of schema type instance.
    * @param {alias} alias Targeted generic alias.
    */
-  type ObtainSchemaGeneric<TSchema, alias extends 'EnforcedDocType' | 'M' | 'TInstanceMethods' | 'TQueryHelpers' | 'TVirtuals' | 'TStaticMethods' | 'TSchemaOptions' | 'DocType'> =
-   TSchema extends Schema<infer EnforcedDocType, infer M, infer TInstanceMethods, infer TQueryHelpers, infer TVirtuals, infer TStaticMethods, infer TSchemaOptions, infer DocType>
+  type ObtainSchemaGeneric<TSchema, alias extends 'EnforcedDocType' | 'M' | 'TInstanceMethods' | 'TQueryHelpers' | 'TVirtuals' | 'TStaticMethods' | 'TSchemaOptions' | 'TSchemaDefinition' | 'DocType'> =
+   TSchema extends Schema<infer EnforcedDocType, infer M, infer TInstanceMethods, infer TQueryHelpers, infer TVirtuals, infer TStaticMethods, infer TSchemaOptions, infer TSchemaDefinition, infer DocType>
      ? {
        EnforcedDocType: EnforcedDocType;
        M: M;
@@ -56,6 +56,7 @@ declare module 'mongoose' {
        TVirtuals: TVirtuals;
        TStaticMethods: TStaticMethods;
        TSchemaOptions: TSchemaOptions;
+       TSchemaDefinition: TSchemaDefinition;
        DocType: DocType;
      }[alias]
      : unknown;
@@ -76,7 +77,7 @@ declare module 'mongoose' {
 
 type IsPathDefaultUndefined<PathType> = PathType extends { default: undefined } ?
   true :
-  PathType extends { default: (...args: any[]) => undefined } ?
+  PathType extends { default: (this: any, ...args: any[]) => undefined } ?
     true :
     false;
 
@@ -86,13 +87,13 @@ type IsPathDefaultUndefined<PathType> = PathType extends { default: undefined }
  * @param {TypeKey} TypeKey A generic of literal string type."Refers to the property used for path type definition".
  */
 type IsPathRequired<P, TypeKey extends string = DefaultTypeKey> =
-  P extends { required: true | [true, string | undefined] | { isRequired: true } } | ArrayConstructor | any[]
+  P extends { required: true | [true, string | undefined] | { isRequired: true } } | ArrayConstructor | any[] | ReadonlyArray<any>
     ? true
     : P extends { required: boolean }
       ? P extends { required: false }
         ? false
         : true
-      : P extends (Record<TypeKey, ArrayConstructor | any[]>)
+      : P extends (Record<TypeKey, ArrayConstructor | any[] | ReadonlyArray<any>>)
         ? IsPathDefaultUndefined<P> extends true
           ? false
           : true