CODEWITHSUNDEEP
javascriptmongodbmeteor
nitomoe
nitomoe

Reputation: 177

Meteor: Return only single object in nested array within collection

I'm attempting to filter returned data sets with Meteor's find().fetch() to contain just a single object, it doesn't appear very useful if I query for a single subdocument but instead I receive several, some not even containing any of the matched terms.

I have a simple mixed data collection that looks like this:

{
    "_id" : ObjectId("570d20de3ae6b49a54ee01e7"),
    "name" : "Entertainment",
    "items" : [
        {
            "_id" : ObjectId("57a38b5f2bd9ac8225caff06"),
            "slug" : "this-is-a-long-slug",
            "title" : "This is a title"
        },
        {
            "_id" : ObjectId("57a38b835ac9e2efc0fa09c6"),
            "slug" : "mc",
            "title" : "Technology"
        }
    ]
}
{
    "_id" : ObjectId("570d20de3ae6b49a54ee01e8"),
    "name" : "Sitewide",
    "items" : [
        {
            "_id" : ObjectId("57a38bc75ac9e2efc0fa09c9"),
            "slug" : "example",
            "name" : "Single Example"
        }
    ]
}

I can easily query for a specific object in the nested items array with the MongoDB shell as this:

db.categories.find( { "items.slug": "mc" }, { "items.$": 1 } );

This returns good data, it contains just the single object I want to work with:

{
    "_id" : ObjectId("570d20de3ae6b49a54ee01e7"),
    "items" : [
        {
            "_id" : ObjectId("57a38b985ac9e2efc0fa09c8")
            "slug" : "mc",
            "name" : "Single Example"
        }
     ]
}

However, if a similar query within Meteor is directly attempted:

/* server/publications.js */
Meteor.publish('categories.all', function () {
    return Categories.find({}, { sort: { position: 1 } });
});
/* imports/ui/page.js */
Template.page.onCreated(function () {
    this.subscribe('categories.all');
});
Template.page.helpers({
    items: function () {
        var item = Categories.find(
            { "items.slug": "mc" },
            { "items.$": 1 } )
        .fetch();
        console.log('item: %o', item);
     }
 });

The outcome isn't ideal as it returns the entire matched block, as well as every object in the nested items array:

{
    "_id" : ObjectId("570d20de3ae6b49a54ee01e7"),
    "name" : "Entertainment",
    "boards" : [
        {
            "_id" : ObjectId("57a38b5f2bd9ac8225caff06")
            "slug" : "this-is-a-long-slug",
            "name" : "This is a title"
        },
        {
            "_id" : ObjectId("57a38b835ac9e2efc0fa09c6")
            "slug" : "mc",
            "name" : "Technology"
        }
    ]
}

I can then of course filter the returned cursor even further with a for loop to get just the needed object, but this seems unscalable and terribly inefficient while dealing with larger data sets.

I can't grasp why Meteor's find returns a completely different set of data than MongoDB's shell find, the only reasonable explanation is both function signatures are different.

Should I break up my nested collections into smaller collections and take a more relational database approach (i.e. store references to ObjectIDs) and query data from collection-to-collection, or is there a more powerful means available to efficiently filter large data sets into single objects that contain just the matched objects as demonstrated above?

Upvotes: 3

Views: 1881

Answers (1)

hwillson
hwillson

Reputation: 1399

The client side implementation of Mongo used by Meteor is called minimongo. It currently only implements a subset of available Mongo functionality. Minimongo does not currently support $ based projections. From the Field Specifiers section of the Meteor API:

Field operators such as $ and $elemMatch are not available on the client side yet.

This is one of the reasons why you're getting different results between the client and the Mongo shell. The closest you can get with your original query is the result you'll get by changing "items.$" to "items":

Categories.find(
  { "items.slug": "mc" },
  { "items": 1 } 
).fetch();

This query still isn't quite right though. Minimongo expects your second find parameter to be one of the allowed option parameters outlined in the docs. To filter fields for example, you have to do something like:

Categories.find(
  { "items.slug": "mc" },
  { 
    fields: {
      "items": 1
    }
  }
).fetch();

On the client side (with Minimongo) you'll then need to filter the result further yourself.

There is another way of doing this though. If you run your Mongo query on the server, you won't be using Minimongo, which means projections are supported. As a quick example, try the following:

/server/main.js

const filteredCategories = Categories.find(
  { "items.slug": "mc" },
  {
    fields: {
      "items.$": 1
    }
  }
).fetch();
console.log(filteredCategories);

The projection will work, and the logged results will match the results you see when using the Mongo console directly. Instead of running your Categories.find on the client side, you could instead create a Meteor Method that calls your Categories.find on the server, and returns the results back to the client.

Upvotes: 1

Related Questions