[Question] Populate a Map

[InsOpDe]

Question
I have schema type Map in my mongoose model. In this map, each element has reference to another model. I know that it's possible to populate attributes in array, but how about Map type? Be cause nesting like "map_type_attribute.some_attribute_to_populate" doesn't work. :)

This is my model:

const Mongoose = require('mongoose');

const parameter = Mongoose.Schema({
  definition: {
    type: Mongoose.Schema.Types.ObjectId,
    ref:  'Definition',
  },
  value:      {},
}, {_id: false});

const schema = Mongoose.Schema({
  model:      {
    type: Mongoose.Schema.Types.ObjectId,
    ref:  'Model'
  },
  name:       String,
  objectid:   Number,
  externalId: String,
  properties: Mongoose.Schema.Types.Mixed,
  parameters: {
    type: Map,
    of:   parameter
  }
});

module.exports = Mongoose.model('Element', schema);

This is how i'm trying to populate definition field:

 const request = Element.find(query, projection);
  request.populate('parameters.definition');
  request.exec( (err, docs) => {
...

What are the versions of Node.js, Mongoose and MongoDB you are using? Note that "latest" is not a version.
node: v13.13.0
mongoose: 5.9.26
mongodb (docker): bitnami/mongodb:4.2.8-debian-10-r47

[vkarpov15]

Confirmed, here's the repro script:

'use strict';

const mongoose = require('mongoose');

const { Schema } = mongoose;

mongoose.set('debug', true);

run().catch(err => console.log(err));

async function run() {
  await mongoose.connect('mongodb://localhost:27017/test', {
    useNewUrlParser: true,
    useUnifiedTopology: true
  });

  await mongoose.connection.dropDatabase();

const parameter = Schema({
  definition: {
    type: mongoose.Schema.Types.ObjectId,
    ref:  'Definition',
  },
  value:      {},
}, {_id: false});

const schema = Schema({
  model:      {
    type: mongoose.Schema.Types.ObjectId,
    ref:  'Model'
  },
  name:       String,
  objectid:   Number,
  externalId: String,
  properties: mongoose.Schema.Types.Mixed,
  parameters: {
    type: Map,
    of:   parameter
  }
});

  const Definition = mongoose.model('Definition', Schema({ text: String }));
  const Element = mongoose.model('Element', schema);

  const def = await Definition.create({ text: 'test' });
  await Element.create({ parameters: { test: { definition: def } } });

  const doc = await Element.findOne().populate('parameters.$*.definition');
  console.log(doc.parameters);
}

[vkarpov15]

Thanks for reporting, fix will be in 5.10.3. You'll have to do Element.findOne().populate('parameters.$*.definition');, note the $* part.

[ManimuthurajT]

@vkarpov15

I have schema type Map in my mongoose model. How to use refPath in Map?using "values.$*.refp" doesn't work.
This is my model:

`const fieldValuesSchema = new Schema({
fieldId: { type: Schema.Types.ObjectId, required: true },
valueObject: {
type: Schema.Types.ObjectId,
refPath: "values.$*.refp",
},
modelName: {
type: Schema.Types.String,
},
});

const rowSchema =new Schema ({
listId: { type: Schema.Types.ObjectId, required: true },
values: { type: Schema.Types.Map, of: listFieldValuesSchema },
});
`

[vkarpov15]

@ManimuthurajT where is refp and listFieldValuesSchema defined?

[ManimuthurajT]

Thanks for your response here is the definition of refp and listFieldValuesSchema defined

const listFieldValuesSchemaDef = {
    ...
    value: {
        type: Schema.Types.Mixed,
    },
    valueObject: {
        type: Schema.Types.ObjectId,
        refPath: "values.$*.refp",
    },
    refp: {
        type: Schema.Types.String,
    },
};

const listRowSchemaDef = {
    ...
    values: { type: Schema.Types.Map, of: listFieldValuesSchema },
};

[ManimuthurajT]

@vkarpov15 repro script

const mongoose = require("mongoose");

const { Schema } = mongoose;

mongoose.set("debug", true);

run().catch((err) => console.log(err));

async function run() {
  await mongoose.connect("mongodb://localhost:27017/test", {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  });

  await mongoose.connection.dropDatabase();

  // user schema
  const userSchema = Schema({
    name: { type: mongoose.Schema.Types.String, required: true },
  });

  // list schema
  const listSchema = Schema({
    listName: { type: mongoose.Schema.Types.String, required: true },
  });

  // row value schema
  const rowValuesSchema = Schema({
    valueObject: {
      type: mongoose.Schema.Types.ObjectId,
      refPath: "values.$*.refp",
    },
    refp: {
      type: mongoose.Schema.Types.String,
    },
  });

  // row schema
  const rowSchema = Schema({
    sortOrder: { type: mongoose.Schema.Types.Number, required: true },
    values: { type: mongoose.Schema.Types.Map, of: rowValuesSchema },
  });

  const User = mongoose.model("User", userSchema);
  const List = mongoose.model("List", listSchema);
  const Row = mongoose.model("Row", rowSchema);

  const createUser = await User.create({ name: "test" });
  const createList = await List.create({ listName: "hi" });

  await Row.create({
    sortOrder: 1,
    values: {
      [createList._id]: {
        valueObject: mongoose.Types.ObjectId(createUser._id),
        refp: "User",
      },
    },
  });

  const row = await Row.findOne().populate({
    path: "values",
    populate: { path: "valueObject" },
  });
  console.log("row", row);
}```

[vkarpov15]

@ManimuthurajT here's what you do what you're trying to do:

  const row = await Row.findOne().populate({
    path: "values.$*.valueObject" // <-- no need for deep populate since `values` is already a property in row
  });

There's a bug that prevents refPath from working with maps of subdocs, we're fixing that for v6.1.4. As a workaround, you can do:

  // row value schema
  const rowValuesSchema = Schema({
    valueObject: {
      type: mongoose.Schema.Types.ObjectId,
      ref: subdoc => subdoc.refp // <-- use `ref` function syntax rather than `refPath`
    },
    refp: {
      type: mongoose.Schema.Types.String,
    },
  });