Mongoose: Reference a schema in another schema (with examples)

Introduction

Mongoose is a robust tool for managing data in MongoDB applications. In this tutorial, you’ll learn how to streamline your models and foster relationships between collections with the power of document references. This is an essential feature when dealing with related data – such as users and their posts in a social media application. We’ll start with the basics of schema references and gradually explore more complex relationships, taking advantage of latest ECMAScript features like async/await and arrow functions for cleaner, more readable code. Let’s dive in!

Defining Your Schemas

Before creating references, ensure you have installed Mongoose:

npm install mongoose

We’ll consider two collections: a user collection and a blog post collection.

User Schema:

import mongoose from 'mongoose';

const userSchema = new mongoose.Schema({
  username: String,
  email: String,
  // Other fields
});

const User = mongoose.model('User', userSchema);
export default User;

Post Schema:

import mongoose from 'mongoose';

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

const Post = mongoose.model('Post', postSchema);
export default Post;

Here, the author field references the User schema, creating a link between a post and a user.

Basic Usage

Let’s create a new post by a given user:

async function createPost(userData, postData) {
  const user = new User(userData);
  await user.save(); // Save user first to get an id

  const post = new Post({ ...postData, author: user._id});
  await post.save();

  return post;
}

With the reference in place, you can now use Mongoose’s populate() method to fill in the details of the linked user when querying posts:

async function getPostWithAuthor(postId) {
  const post = await Post.findById(postId)
   .populate('author', 'username email'); // Only include certain fields

  return post;
}

Organizing References

As your application grows, you might need separate folders for your models.

// models/user.js

// User schema defined here

// models/post.js

// Post schema defined here

This organization is crucial in larger projects for readability and maintainability of your codebase.

Advanced Relationships

Suppose we want to keep track of both the user’s posts and liked posts within our User schema. We can set up an array of references to manage this connection:

import mongoose from 'mongoose';

// Revised User Schema
const userSchema = new mongoose.Schema({
  username: String,
  email: String,
  posts: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Post'
  }],
  likes: [{
    type: mongoose.Schema.Types.ObjectId,
    ref: 'Post'
  }]
});

Whenever a user creates a new post, you’ll make sure to update both the Post and User collections:

async function createUserPost(userId, postData) {
  const post = new Post({ ...postData, author: userId });
  await post.save();

  const user = await User.findById(userId);
  user.posts.push(post._id); // Add the post's ID to user's posts
  await user.save();

  return { user, post };
}

With bidirectional relationships implemented like this, it’s easy to aggregate data based on user activities.

Working with Population

Deep population can be handy:

async function getUserWithPosts(userId) {
  const user = await User.findById(userId)
    .populate({
      path: 'posts',
      select: 'title content'
    });

  return user;
}

You could also use aggregation functions to further manage relationships.

Error Handling and Validation

It’s crucial to handle cases where related IDs might not correspond to actual documents:

async function getPostSafe(postId) {
  const post = await Post.findById(postId)
    .populate('author')
    .catch((error) => { console.error('Error fetching post:', error); });

  if (!post.author) {
    // Handle missing author
  }

  return post;
}

Larger applications often have complex data relationships. At scale, you’d keep your schema architecture DRY and optimize queries.

You have the flexibility to structure your Mongoose schemas to leverage MongoDB’s strengths and match the needs of your application logic.

Conclusion

Throughout this tutorial, you’ve been taken from the elementary steps of referencing schemas within Mongoose to the intricate designs you’ll encounter in professional environments. Leveraging these techniques allows the data in your applications to maintain integrity while you work with them in an elegant and efficient manner.