Allow populating paths with spaces

[vkarpov15]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the issue has not already been raised

Issue

The following test fails, there's no way to populate the 'original author' path that I can see:

    it('allows populating path with space in name (gh-13951)', async function() {
      const BlogPost = db.model('BlogPost', new Schema({
        title: String,
        'original author': { type: ObjectId, ref: 'User' },
        author: { type: ObjectId, ref: 'User' }
      }));
      const User = db.model('User', new Schema({ name: String }));

      const fans = await User.create([{ name: 'Fan 1' }]);
      const posts = [
        { title: 'Test 1', author: fans[0]._id, 'original author': fans[0]._id }
      ];
      await BlogPost.create(posts);
      const blogPost = await BlogPost.
        findOne({ title: 'Test 1' }).
        populate({ path: 'original author' });

      assert.equal(blogPost['original author'].name, 'Fan 1');
      assert.equal(blogPost.title, 'Test 1');
    });

Worth finding a way to support this behavior without breaking existing logic that relies on whitespace to separate multiple paths.

[vkarpov15]

This isn't quite as simple as I thought when looking at #15231 because we have tests that assert that populate({ path: ['foo bar'] }) is equivalent to populate({ path: ['foo', 'bar'] }) from #6414.

We should consider changing this behavior in 9.0. @AbdelrahmanHafez do you have any thoughts as the original reporter of #6414?

[AbdelrahmanHafez]

Makes sense, I am not sure if Mongo always supported spaces in paths or if it's a new feature.
A possible solution would be to do some matching with the schema, with a field that includes space would have a higher priority over splitting: pseudo-code would look like this:

function processPathToPopulate(pathToPopulate) {
  // path exists as is in schema, regardless of whether or not it has spaces
  if (schemaPaths.include(pathToPopulate)) {
    // use that path
  } else {
    pathToPopulate.split(' ').forEach(processPathToPopulate)
  }
}

This would make a corner case where if a schema has the three following fields original author, original, and author. Populating original author would try to match original author, and if that field exists, we'd populate that directly, otherwise we'd try to split and populate like we used to.

I do understand that the implementation might not be as simple as this though, if you have bigger fish to fry, maybe we can just introduce breaking changes.
Or maybe I can contribute a little bit to the project I've been far from. 😄

What do you think? @vkarpov15

[vkarpov15]

The idea of checking schemaPaths is a neat workaround, but my first reaction is that may be a bit too clever and potentially hard to read because you can't tell the behavior of .populate({ path: ['original author'] }) without looking at the schema. I think assuming that if path is an array of strings then we don't need to split those strings by ' ' is a bit easier to understand.

[AbdelrahmanHafez]

That also works. 👍
I don't think anyone out there is doing ['original author'] with the intention of populating multiple fields.
If a need for that trick to be implemented in the future arises, we can always implement it as a non-backwards breaking change.