TypeScript Express tutorial #13. Using Mongoose virtuals to populate documents

栏目: IT技术 · 发布时间: 4年前

内容简介:Throughout this series, we’ve created some schemas and models for documents. We’ve also established ways to define relationships between them. We sometimes find ourselves needing many different properties in our documents. They sometimes overlap each other

Throughout this series, we’ve created some schemas and models for documents. We’ve also established ways to define relationships between them. We sometimes find ourselves needing many different properties in our documents. They sometimes overlap each other, and we might want to avoid duplicating the data in the database. Also, we might want to avoid two-way referencing that we discussed in the fifth part of this series . The solution to all of the above issues might be  virtuals . To understand them, we also inspect  getters and  setters first.

You can find all of the code from this series in this repository . Feel free to give it a star and share it.

Getters and Setters in Mongoose

The first concept to wrap our heads around is the idea of getters and  setters . They allow us to execute custom logic whenever we are getting and setting properties in a document.

Getters

With getters, we can modify the data of a document. Let’s assume that the user has the credit card number that we don’t want to fully present.

const userSchema = new mongoose.Schema(
  {
    email: String,
    name: String,
    password: String,
    creditCardNumber: {
      type: String,
      get: (creditCardNumber: string) => {
        return `****-****-****-${
          creditCardNumber.substr(creditCardNumber.length - 4)
        }`;
      },
    },
  },
  {
    toJSON: { getters: true },
  },
);

In the above example, every time the User document is pulled from the database, we obfuscate the credit card number to protect it.

To make our changes reflect in the response, we need to pass additional options to the mongoose . Schema constructor. When we respond with the data of a user, Express calls the toJSON function internally. If we want the getters to apply, we need to set  getters : true as above.

Documents also have the toObject method that we can also customize similarly.

A useful use-case for the above might be to make sure that the password of the user never gets sent back in response.

const userSchema = new mongoose.Schema(
  {
    email: String,
    name: String,
    password: {
      type: String,
      get: (): undefined => undefined,
    },
  },
  {
    toJSON: {
      getters: true,
    },
  },
);

By creating such a getter, we avoid leaking sensitive data. We just need to remember that if we need to access the password, we need the Document.prototype.get() function with an additional option.

const isPasswordMatching = await bcrypt.compare(
  logInData.password,
  user.get('password', null, { getters: false }),
);

Since we rarely need to access the password property, it is a more fitting approach to hide it by default.

Setters

Using setters, we can modify the data before it is populated in the database. With them, we can inject additional logic and modify the data.

import createPasswordHash from './createPasswordHash'
 
const userSchema = new mongoose.Schema({
  email: String,
  name: String,
  password: {
    type: String,
    set: (plaintextPassword: string) => {
      return createPasswordHash(plaintextPassword);
    },
  },
});

You might prefer to have the above logic inside your services instead of using setters. Even if that’s the case, it is good to be aware of the above functionality.

Mongoose virtuals

A Virtual is an additional property of a document. We can get it and  set it, but it does not persist in the MongoDB database.

A typical example might be with names. First, let’s create a firstName property without the use of virtuals.

const userSchema = new mongoose.Schema({
  email: String,
  firstName: String,
  lastName: String,
  fullName: String,
  password: String,
});

TypeScript Express tutorial #13. Using Mongoose virtuals to populate documents

​The above approach has a few issues. By persisting the fullName data into MongoDB, we duplicate the information, which is unnecessary. Also, imagine that at some point, we would like to support a middle name and make it a part of the  fullName . A more fitting approach would be to attach the  fullName dynamically.

Getters

We can do the above with the use of virtuals . Let’s create it along with a  getter .

const userSchema = new mongoose.Schema(
  {
    email: String,
    firstName: String,
    lastName: String,
    password: String,
  },
  {
    toJSON: { virtuals: true },
  },
);
 
userSchema.virtual('fullName').get(function () {
  return `${this.firstName} ${this.lastName}`;
});

Now, every time we pull the user entity from the database, we also create the fullName property dynamically.

Similarly to regular getters, we also need to pass additional options to the Document.prototype.get() constructor. Thanks to adding  toJSON : { virtuals : true } above, our virtual properties are visible when converting to JSON.

Now, when we inspect our database, we can see that the fullName field is not populated:

TypeScript Express tutorial #13. Using Mongoose virtuals to populate documents

Setters

Virtuals also support setters . With them, we can set multiple properties at once.

userSchema.virtual('fullName')
  .get(function () {
    return `${this.firstName} ${this.lastName}`;
  })
  .set(function (fullName: string) {
    const [firstName, lastName] = fullName.split(' ');
    this.set({ firstName, lastName });
  });

In the above example, we set the firstName and  lastName properties based on the  fullName . Within the  setter function of a Virtual,  this refers to the document.

Populating virtuals

One of the most useful features of virtuals is populating documents from another collection.

In the fifth part of this series , we discuss the relationships between documents. The direction of the reference is an essential mention in the above article. Let’s bring one of the examples again:

const postSchema = new mongoose.Schema({
  author: {
    ref: 'User',
    type: mongoose.Schema.Types.ObjectId,
  },
  content: String,
  title: String,
});

In the above schema, we keep the reference to users in the Post document. Therefore, the documents look like that:

{
  "author": "5e40382687aa217496466bad",
  "title": "Lorem ipsum",
  "content": "Dolor sit amet"
}

Once we settle for one of the above approaches to storing references, we don’t have the information on the other side of the relationship. If we store the reference inside of a post, the user document does not hold the information about posts:

{
  "_id": "5e40382687aa217496466bad",
  "name": "John",
  "email": "john@smith.com"
}

We could do it the other way around instead.

const userSchema = new mongoose.Schema({
  email: String,
  name: String,
  password: String,
  posts: [
    {
      ref: 'Post',
      type: mongoose.Schema.Types.ObjectId,
    },
  ],
});

Doing so would mean that the posts do not contain information about the authors. We could implement two-way referencing, as described in the mentioned article, but it comes with some disadvantages.

Solving the issue with virtuals

To tackle the above problem, we can implement a virtual property:

userSchema.virtual('posts', {
  ref: 'Post',
  localField: '_id',
  foreignField: 'author',
});

In the above code, we connect the _id of a user to the  author of a post. We also tell Mongoose through ref wich model to populate documents from.

The only thing that’s left is to use the populate function.

src/user/user.controller.ts

private initializeRoutes() {
  this.router.get(`${this.path}/:id`, authMiddleware, this.getUserById);
}
private getUserById = async (request: Request, response: Response, next: NextFunction) => {
  const id = request.params.id;
  const user = await this.user.findById(id).populate('posts');
  if (user) {
    response.send(user);
  } else {
    next(new UserNotFoundException(id));
  }
}
You might want to implement some additional authorization to prevent every authenticated user to have the access to all the users

An important issue that we should address here is that the populate function takes some additional time to finish. A way to tackle this issue is to implement an additional query param.

src/user/user.controller.ts

private getUserById = async (request: Request, response: Response, next: NextFunction) => {
  const id = request.params.id;
  const userQuery = this.user.findById(id);
  if (request.query.withPosts === 'true') {
    userQuery.populate('posts').exec();
  }
  const user = await userQuery;
  if (user) {
    response.send(user);
  } else {
    next(new UserNotFoundException(id));
  }
}

Now we populate the posts array only if it was explicitly asked for through query parameters by calling  users / [ id ] ? withPosts = true .

Summary

In this article, we’ve gone through the idea of virtuals. To fully grasp the concept, we’ve investigated getters and  setters first. Thanks to doing so, we’ve managed to improve our code. By populating the virtual properties, we’ve found another solution to a common issue with references. Doing all of the above gives us lots of new possibilities on how to tackle everyday challenges.


以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

CSS 压缩/解压工具
CSS 压缩/解压工具

在线压缩/解压 CSS 代码

MD5 加密
MD5 加密

MD5 加密工具

正则表达式在线测试
正则表达式在线测试

正则表达式在线测试