Document method types are missing methods when queried from statics

[domharrington]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the bug has not already been reported

Mongoose version

8.16.3

Node.js version

20.19.0

MongoDB server version

7.0.15

Typescript version (if applicable)

5.8.3

Description

Typescript method types are getting dropped if they are returned from a query called from a static method.

Steps to Reproduce

I have the following code (heavily inspired by the docs):

import mongoose from 'mongoose';

const userSchema = new mongoose.Schema(
  {
    name: { type: String, required: true },
  },
  {
    methods: {
      updateName(name: string) {
        this.name = name;
        return this.save();
      }
    },
    statics: {
      findByName(name: string) {
        return this.findOne({ name });
      }
    }
  }
);
const UserModel = mongoose.model('User', userSchema);

const doc = new UserModel({ name: 'test' });
// Compiles correctly
doc.updateName('foo');

const foundDoc = await UserModel.findOne({ name: 'test' }).orFail();
// Compiles correctly
foundDoc.updateName('foo');

const foundDocFromStatic = await UserModel.findByName('test').orFail();
// Method types are broken
foundDocFromStatic.updateName('foo');

The foundDoc variable has the updateName method typed correctly. The foundDocFromStatic variable seems to have lost the method typing information, even though findByName also just does a findOne():

Expected Behavior

I would expect method types to be returned when the query is happening from a static.

Am I doing something wrong here? Thanks in advance.

[vkarpov15]

Nope you're not doing anything wrong. This looks like a bug in our TypeScript types. We're working on a fix.

[vkarpov15]

Still working on a fix, but haven't been able to figure this one out yet. You should be able to work around this with the following:

  type HydratedDocumentType = ReturnType<(typeof UserModel)['hydrate']>
  const foundDocFromStatic = await UserModel.findByName('test').orFail() as HydratedDocumentType;
  // Method types are broken
  foundDocFromStatic.updateName('foo');

[domharrington]

Thank you! If it helps at all, the type returned from the normal findOne() call looks like this:

const foundDoc: mongoose.Document<unknown, {}, {
    name: string;
}, {}> & Omit<{
    name: string;
} & {
    _id: mongoose.Types.ObjectId;
} & {
    __v: number;
}, "updateName"> & {
    ...;
}

But the type from the static looks like this:

const foundDocFromStatic: mongoose.Document<unknown, {}, mongoose.FlatRecord<{
    name: string;
}>, {}> & mongoose.FlatRecord<{
    name: string;
}> & {
    _id: mongoose.Types.ObjectId;
} & {
    __v: number;
}

So the main difference being the properties are getting wrapped in a mongoose.FlatRecord type.

Let me know if there's anything I can do to assist here. Happy to dig in and help as well.

[vkarpov15]

FlatRecord<> is a red herring here, that just transforms the document properties. The real issue is that SchemaOptions needs to know the type of methods when processing statics. Before #15537 we just had this: Model<DocType> in statics, which meant the model in statics didn't know about methods, virtuals, etc. Even with #15537, we still have the issue where the type of TInstanceMethods isn't known yet when we create TModelType.