What is the best way to fill in and subsequently find matches using the 'parent' identifier?

Question

What is the best way to fill in and subsequently find matches using the 'parent' identifier?

I am currently working on associating a populated referenced document with the parent document id. The main objective is to display only the membership permissions related to a specific organization, rather than showing all other permissions that may exist. This means that the 'entity.item', which represents an organization in this case, should be linked to the parent organization id. I am exploring ways to access the parent organization id from a child document.

let userId = '123';
let organizations = await Organization.find().where('members.includes(userId)').populate({
    path: 'members',
    options: { sort: { name: 1 } },
    populate: {
      path: 'permissions',
      match: {
        'entity.kind': 'Organization',
        'entity.item': organization._id  //HERE
      },
      populate: {
        path: 'entity.item'
      }
    }
  });

javascript mongodb mongoose mongoose-populate

Answer 1

Answer №1

After experimenting with the lookup operator in the aggregate method, I have found that it is indeed working well in various test scenarios. Credit goes to the following answer for pointing me in the right direction:

"Utilizing the $lookup syntax introduced in mongodb 3.6 and above makes it straightforward to join nested fields without the need for $unwind."

let organizations = await Organization.aggregate([
  { $sort: { name: 1 } },
  { $match: { $expr: { $in: [ user.id, '$members' ] } } },
  {
    $lookup: {
      from: 'user',
      let: { id: '$_id', members: '$members' },
      pipeline: [
        { $match: { $expr: { $in: [ '$_id', '$$members' ] } } },
        { $addFields: { id: '$_id' } },
        {
          $lookup: {
            from: 'permission',
            pipeline: [
              { $match: { $expr: { $and: [
                { $eq: [ '$entity.kind', 'Organization' ] },
                { $eq: [ '$entity.item', '$$id' ] }
              ] } } },
              { $addFields: { id: '$_id' } },
              {
                $lookup: {
                  from: 'organization',
                  pipeline: [
                    { $match: { $expr: { $eq: [ '$_id', '$$id' ] } } },
                    { $addFields: { id: '$_id' } }
                  ],
                  as: 'entity.item'
                }                      
              }
            ],
            as: 'permissions'
          }
        }
      ],
      as: 'members'
    }
  },
  { $addFields: { id: '$_id' } }
]);

Answer 2

After experimenting with the lookup operator in the aggregate method, I have found that it is indeed working well in various test scenarios. Credit goes to the following answer for pointing me in the right direction:

"Utilizing the $lookup syntax introduced in mongodb 3.6 and above makes it straightforward to join nested fields without the need for $unwind."

let organizations = await Organization.aggregate([
  { $sort: { name: 1 } },
  { $match: { $expr: { $in: [ user.id, '$members' ] } } },
  {
    $lookup: {
      from: 'user',
      let: { id: '$_id', members: '$members' },
      pipeline: [
        { $match: { $expr: { $in: [ '$_id', '$$members' ] } } },
        { $addFields: { id: '$_id' } },
        {
          $lookup: {
            from: 'permission',
            pipeline: [
              { $match: { $expr: { $and: [
                { $eq: [ '$entity.kind', 'Organization' ] },
                { $eq: [ '$entity.item', '$$id' ] }
              ] } } },
              { $addFields: { id: '$_id' } },
              {
                $lookup: {
                  from: 'organization',
                  pipeline: [
                    { $match: { $expr: { $eq: [ '$_id', '$$id' ] } } },
                    { $addFields: { id: '$_id' } }
                  ],
                  as: 'entity.item'
                }                      
              }
            ],
            as: 'permissions'
          }
        }
      ],
      as: 'members'
    }
  },
  { $addFields: { id: '$_id' } }
]);

What is the best way to fill in and subsequently find matches using the 'parent' identifier?

Answer №1

Similar questions

Using Typescript generics to enhance arrays

updating specific keys of nested object in mongoose document

Each instance of the same class receives a unique version

Adding a UUID to the data.json file using Node.js - A step-by-step guide

Encountered an abrupt termination of JSON input while implementing Promise.all() alongside the fetch method's put operation

Utilizing Object Arrays in Chart.js for Optimal Performance

Choosing a value using Jquery on change is not effective

Replacing JS/CSS include sections, the distinction between Debug and Release versions

How can I generate cone shape with rectangular base using three.js?

Finding values within array elements in mongoose documents

Is there a way to display a modal before redirecting to the next page after clicking a submit button in a rails application?

Using SignalR 2.0 to connect to a hub without relying on a proxy

Using a try catch within a try catch block along with the Mongoose library and Express

Which is Better: Lazy Loading, Combining and Minifying, or Using a CDN for Javascript in Angular

Convert this text into HTML code: "Textarea to

I am seeking assistance with incorporating mySQL into my Node.js project with React

What is returned if Select is an empty string in a Mongoose Model.find() query?

What prevents me from displaying the image in the Bootstrap tooltip?

Creating dynamic visual representations of algorithms using JavaScript

Does the onchange function in the dropdown list only work when the first item is changed?