Create mongoose schema methods using TypeScript

Question

I try to create method hashPassword for user schema.

schema.method("hashPassword", function (): void {
  const salt = bcrypt.genSaltSync(10);
  const hash = bcrypt.hashSync(this.password, salt);

  this.password = hash;
});

And get an error Property 'password' does not exist on type 'Document<any>'. on password

Here is my file

import mongoose, { Schema, Document } from "mongoose";
import bcrypt from "bcryptjs";

/**
 * This interface should be the same as JWTPayload declared in types/global.d.ts file
 */
export interface IUser extends Document {
  name: string;
  email: string;
  username: string;
  password: string;
  confirmed: boolean;
  hashPassword: () => void;
  checkPassword: (password: string) => boolean;
}

// User schema
const schema = new Schema(
  {
    name: {
      type: String,
      required: true,
    },
    email: {
      type: String,
      required: true,
    },
    username: {
      type: String,
      required: true,
    },
    password: {
      type: String,
      required: true,
    },
    confirmed: {
      type: Boolean,
      default: false,
    },
  },
  { timestamps: true }
);

schema.method("hashPassword", function (): void {
  const salt = bcrypt.genSaltSync(10);
  const hash = bcrypt.hashSync(this.password, salt);

  this.password = hash;
});

// User model
export const User = mongoose.model<IUser>("User", schema, "users");

Linda Paiste · Accepted Answer · 2021-01-15 01:18:08Z

10

At the point where you define the method, the schema object doesn't know that it is the Schema for an IUser and not just any Document. You need to set the generic type for the Schema when you create it: new Schema<IUser>( ... ).

answered Jan 15, 2021 at 1:18

Linda Paiste

42.6k8 gold badges81 silver badges118 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Sufian Over a year ago

Much simpler than other answers.

Vivek Tiwary · Accepted Answer · 2021-10-30 20:21:06Z

6

As suggested by one of the collaborators of mongoose, we can use the below way for creating instance methods:

const schema = new Schema<ITestModel, Model<ITestModel, {}, InstanceMethods>> // InstanceMethods would be the interface on which we would define the methods

schema.methods.methodName = function() {}

const Model = model<ITestModel, Model<ITestModel, {}, InstanceMethods>>("testModel", ModelSchema)

const modelInstance = new Model();
modelInstance.methodName() // works

link: https://github.com/Automattic/mongoose/issues/10358#issuecomment-861779692

answered Oct 30, 2021 at 20:21

Vivek Tiwary

3002 silver badges10 bronze badges

Comments

Theodore MCA · Accepted Answer · 2022-07-23 02:08:38Z

5

This makes is Clear Enough

import mongoose, { Schema, Document, Model } from "mongoose";
import bcrypt from "bcrypt";

interface IUser {
    username: string;
    hashedPassword: string;
}

interface IUserDocument extends IUser, Document {
    setPassword: (password: string) => Promise<void>;
    checkPassword: (password: string) => Promise<boolean>;
}

interface IUserModel extends Model<IUserDocument> {
    findByUsername: (username: string) => Promise<IUserDocument>;
}

const UserSchema: Schema<IUserDocument> = new Schema({
    username: { type: String, required: true },
    hashedPassword: { type: String, required: true },
});

UserSchema.methods.setPassword = async function (password: string) {
    const hash = await bcrypt.hash(password, 10);
    this.hashedPassword = hash;
};

UserSchema.methods.checkPassword = async function (password: string) {
    const result = await bcrypt.compare(password, this.hashedPassword);
    return result;
};

UserSchema.statics.findByUsername = function (username: string) {
    return this.findOne({ username });
};

const User = mongoose.model<IUserDocument, IUserModel>("User", UserSchema);
export default User;

answered Jul 23, 2022 at 2:08

Theodore MCA

1,20815 silver badges16 bronze badges

2 Comments

somerandomusername Over a year ago

Great example, makes everything nice and clear.

somerandomusername Over a year ago

Make sure not to use arrow functions when defining methods! I usually write arrow functions everywhere, but I forgot that "this" is not available in arrow functions. Took me couple of minutes to remember that.

Chukwunazaekpere · Accepted Answer · 2021-04-26 16:02:14Z

2

You should declare an interface that extends Model like so:

    interface IUser {...}
    interface IUserInstanceCreation extends Model<IUser> {}

then declare your schema;

    const userSchema = new Schema<IUser, IUserInstanceCreation, IUser>({...})

This would as well ensure that the Schema follows the attributes in IUser.

edited Apr 26, 2021 at 16:02

answered Apr 26, 2021 at 15:56

Chukwunazaekpere

1,0221 gold badge8 silver badges16 bronze badges

1 Comment

Dan Tsivinsky Over a year ago

I already figured it out but thank you anyway

Bonarja · Accepted Answer · 2022-08-31 14:32:49Z

2

Solution to avoid having to redefine types that are already in the schema

import { Schema, model, InferSchemaType } from "mongoose"
import bcrypt from "bcrypt"

const userSchema = new Schema({
    name: String,
    email: {
        type: String,
        required: true,
        unique: true
    },
    password: String,
})

userSchema.methods.verifyPassword = async function(password: string){
    return await bcrypt.compare(password, this.password)
}

declare interface IUser extends InferSchemaType<typeof userSchema> {
    verifyPassword(password: string): boolean
}

export const UserModel = model<IUser>("Users", userSchema)

edited Aug 31, 2022 at 14:32

answered Aug 31, 2022 at 14:17

Bonarja

212 bronze badges

Comments

Swapnil Soni · Accepted Answer · 2025-05-29 11:28:19Z

As per mongoose docs To automatically infer type you need to define them in Schema object creation

something like this

// User schema
const schema = new Schema(
  {
    name: {
      type: String,
      required: true,
    },
    email: {
      type: String,
      required: true,
    },
    username: {
      type: String,
      required: true,
    },
    password: {
      type: String,
      required: true,
    },
    confirmed: {
      type: Boolean,
      default: false,
    },
  },
  {
    timestamps: true,
    methods: {
      async hashPassword() {
        const salt = bcrypt.genSaltSync(10);
        const hash = bcrypt.hashSync(this.password, salt);

        this.password = hash;
      }
    }
  }
);

export const User = mongoose.model<IUser>("User", schema, "users")

And simply use it

const user = new User({...})
user.hashPassword() // intellisense will detect it

No need to implicitly define any types/interfaces

Collectives™ on Stack Overflow

Create mongoose schema methods using TypeScript

6 Answers 6

1 Comment

Comments

2 Comments

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

1 Comment

Comments

2 Comments

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related