Merge pull request #14028 from ruxxzebre/fix-tinstancemethod-this

fix: "this" of Schema's instance methods

Author: vkarpov15

test/types/schema.test.ts

@@ -1230,3 +1230,124 @@ async function gh13797() {
     expectType<IUser>(this); return '';
   } } });
 }
+
+function gh14028_methods() {
+  // Methods that have access to `this` should have access to typing of other methods on the schema
+  interface IUser {
+    firstName: string;
+    lastName: string;
+    age: number;
+  }
+  interface IUserMethods {
+    fullName(): string;
+    isAdult(): boolean;
+  }
+  type UserModel = Model<IUser, {}, IUserMethods>;
+
+  // Define methods on schema
+  const schema = new Schema<IUser, UserModel, IUserMethods>({
+    firstName: { type: String, required: true },
+    lastName: { type: String, required: true },
+    age: { type: Number, required: true }
+  }, {
+    methods: {
+      fullName() {
+        // Expect type of `this` to have fullName method
+        expectType<IUserMethods['fullName']>(this.fullName);
+        return this.firstName + ' ' + this.lastName;
+      },
+      isAdult() {
+        // Expect type of `this` to have isAdult method
+        expectType<IUserMethods['isAdult']>(this.isAdult);
+        return this.age >= 18;
+      }
+    }
+  });
+
+  const User = model('User', schema);
+  const user = new User({ firstName: 'John', lastName: 'Doe', age: 20 });
+  // Trigger type assertions inside methods
+  user.fullName();
+  user.isAdult();
+
+  // Expect type of methods to be inferred if accessed directly
+  expectType<IUserMethods['fullName']>(schema.methods.fullName);
+  expectType<IUserMethods['isAdult']>(schema.methods.isAdult);
+
+  // Define methods outside of schema
+  const schema2 = new Schema<IUser, UserModel, IUserMethods>({
+    firstName: { type: String, required: true },
+    lastName: { type: String, required: true },
+    age: { type: Number, required: true }
+  });
+
+  schema2.methods.fullName = function fullName() {
+    expectType<IUserMethods['fullName']>(this.fullName);
+    return this.firstName + ' ' + this.lastName;
+  };
+
+  schema2.methods.isAdult = function isAdult() {
+    expectType<IUserMethods['isAdult']>(this.isAdult);
+    return true;
+  };
+
+  const User2 = model('User2', schema2);
+  const user2 = new User2({ firstName: 'John', lastName: 'Doe', age: 20 });
+  user2.fullName();
+  user2.isAdult();
+
+  type UserModelWithoutMethods = Model<IUser>;
+  // Skip InstanceMethods
+  const schema3 = new Schema<IUser, UserModelWithoutMethods>({
+    firstName: { type: String, required: true },
+    lastName: { type: String, required: true },
+    age: { type: Number, required: true }
+  }, {
+    methods: {
+      fullName() {
+        // Expect methods to still have access to `this` type
+        expectType<string>(this.firstName);
+        // As InstanceMethods type is not specified, expect type of this.fullName to be undefined
+        expectError<IUserMethods['fullName']>(this.fullName);
+        return this.firstName + ' ' + this.lastName;
+      }
+    }
+  });
+
+  const User3 = model('User2', schema3);
+  const user3 = new User3({ firstName: 'John', lastName: 'Doe', age: 20 });
+  expectError<string>(user3.fullName());
+}
+
+function gh14028_statics() {
+  // Methods that have access to `this` should have access to typing of other methods on the schema
+  interface IUser {
+    firstName: string;
+    lastName: string;
+    age: number;
+  }
+  interface IUserStatics {
+    createWithFullName(name: string): Promise<IUser>;
+  }
+  type UserModel = Model<IUser, {}>;
+
+  // Define statics on schema
+  const schema = new Schema<IUser, UserModel, {}, {}, {}, IUserStatics>({
+    firstName: { type: String, required: true },
+    lastName: { type: String, required: true },
+    age: { type: Number, required: true }
+  }, {
+    statics: {
+      createWithFullName(name: string) {
+        expectType<IUserStatics['createWithFullName']>(schema.statics.createWithFullName);
+        expectType<UserModel['create']>(this.create);
+
+        const [firstName, lastName] = name.split(' ');
+        return this.create({ firstName, lastName });
+      }
+    }
+  });
+
+  // Trigger type assertions inside statics
+  schema.statics.createWithFullName('John Doe');
+}

types/index.d.ts

@@ -297,7 +297,7 @@ declare module 'mongoose' {
     method(obj: Partial<TInstanceMethods>): this;
 
     /** Object of currently defined methods on this schema. */
-    methods: { [F in keyof TInstanceMethods]: TInstanceMethods[F] } & AnyObject;
+    methods: AddThisParameter<TInstanceMethods, THydratedDocumentType> & AnyObject;
 
     /** The original object passed to the schema constructor */
     obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>, EnforcedDocType>;

types/schemaoptions.d.ts

@@ -210,7 +210,7 @@ declare module 'mongoose' {
       TStaticMethods,
       {},
       { [name: string]: (this: Model<DocType>, ...args: any[]) => unknown },
-      { [F in keyof TStaticMethods]: TStaticMethods[F] }
+      AddThisParameter<TStaticMethods, Model<DocType>>
     >
 
     /**
@@ -220,7 +220,7 @@ declare module 'mongoose' {
     TInstanceMethods,
     {},
     Record<any, (this: THydratedDocumentType, ...args: any) => unknown>,
-    TInstanceMethods
+    AddThisParameter<TInstanceMethods, THydratedDocumentType> & AnyObject
     >
 
     /**

types/utility.d.ts

@@ -40,4 +40,26 @@ 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): 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
+    ? ThisParameter<T[K], unknown> extends unknown
+      ? (this: D, ...args: A) => R
+      : T[K]
+    : T[K];
+};
+
 }