如何在数组中查询带有猫鼬的子文档？

Question

I am looking to query a subdocument that contains an array.

You can think of this as an application similar to medium.com or tumblr.com:

I have a user schema, and User's have many Posts. My post schema has a 'tags' key which is an array I am trying to create a route which will display all posts that have a certain tag.

So for instance,

GET /user/posts/:tag
GET /user/posts/dogs

might return back the data for all posts (by any user) that have the tag 'dogs'

{
  description: 'dogs are cool',
  title: 'huskies',
  tags: ['dogs','animals','outdoors'],
  original_poster: '34255352426'
},{
  description: 'My puppies are nice',
  title: 'Puppies',
  tags: ['pugs','dogs','small'],
  original_poster: '44388342426'
},{
  description: 'I like cats more than dogs',
  title: 'Cats',
  tags: ['kittens','cats','dogs'],
  original_poster: '15708213454'
} 

Here is my User Schema:

const mongoose = require('mongoose'),
    Schema = mongoose.Schema,
    PostSchema = require('./post-model.js');

let UserSchema = new Schema({
    email: {
        type: String,
        required: true,
        unique: true
    },
    username: {
        type: String,
        required: true,
        unique: true
    },
    password: {
        type: String,
        required: false, //only required for local users
        unique: false,
        default: null
    },
    following: {
        type: [Number], 
        required: false,
        unique: false
    },
    followers: {
        type: [Number],
        required: false,
        unique: false
    },
    posts: [PostSchema],
})

module.exports = mongoose.model('User',UserSchema);

Here is my Post Schema:

const mongoose = require('mongoose'),
    Schema = mongoose.Schema;

let PostSchema = new Schema({
    description: {
        type: String,
        required: false,
        unique: false
    },
    title: {
        type: String,
        required: false,
        unique: false
    },
    tags: {
        type: [String],
        required: true
    },
    original_poster: { 
      type: String,
      required: true
    }
});

module.exports = PostSchema;

EDIT:

to clarify my question, imagine that this was a regular js object, here is what a function to return all data relevant to a specific tag:

let users = [];
let user1 = {
  username: 'bob',
  posts: [
    {
      title: 'dogs r cool',
      tags: ['cats','dogs']
    },
    {
      title: 'twd is cool',
      tags: ['amc','twd']
    }]
};
let user2 = {
  username: 'joe',
  posts: [{
    title: 'mongodb is a database system that can be used with node.js',
    tags: ['programming','code']
  },
  {
    title: 'twd is a nice show',
    tags: ['zombies','horror-tv','amc']
  },
    {
      title: 'huskies are my favorite dogs',
      tags: ['huskies','dogs']
    }]
}

users.push(user1);
users.push(user2);

function returnPostByTag(tag) {
  let returnedPosts = [];

  users.forEach((user,i) => {
    user.posts.forEach((post) => {
      if(post.tags.includes(tag)) {
        let includespost = {}
        includespost.title = post.title;
        includespost.tags = post.tags;
        includespost.original_poster = user.username;
        returnedPosts.push(includespost);
      }
    })
  })
  return returnedPosts;
}

If you want to see a full repl where I use a plain js example here it is: https://repl.it/repls/LavenderHugeFireant

Answer 1

You can do the following using Mongoose to return all users where the tags array in any of the subdocuments in the posts array includes tag :

User.find({ 'posts.tags': tag }, function(err, users) {
  if (err) {
    // Handle error
  }

  let filteredPosts = users
    .map(user => {
      user.posts.forEach(post => post.original_poster = user.username)
      return user
    })
    .map(user => user.posts)
    .reduce((acc, cur) => acc.concat(cur), [])
    .filter(post => post.tags.includes(tag))

  // Do something with filteredPosts
  // ...such as sending in your route response
})

...where User is your Mongoose model and tag contains the tag string you want to query (perhaps from your route request).

If you are using promises then you could do:

User.find({ 'posts.tags': tag })
  .then(users => {

    let filteredPosts = users
      .map(user => {
        user.posts.forEach(post => post.original_poster = user.username)
        return user
      })
      .map(user => user.posts)
      .reduce((acc, cur) => acc.concat(cur), [])
      .filter(post => post.tags.includes(tag))

    // Do something with filteredPosts
    // ...such as sending in your route response

  })
  .catch(err => {
    // Handle error
  })