Mongoose Insert Multiple Related Records at once - node.js

Question

Currently I have the following, effective inserting one lyric per song at a time:
SongSchema.statics.addLyric = function(songId, title, content) {
const Lyric = mongoose.model('lyric');
return this.findById(songId).then(song => {
const lyric = new Lyric({ title, content, song });
song.lyrics.push(lyric);
return Promise.all([lyric.save(), song.save()]).then(([lyric, song]) => song);
});
};
However I would like to update this to something like the following, where I pass multiple lyrics at once in an array...
SongSchema.statics.addLyric = function(songId, lyrics) {
...
};
Is it possible to insert all the lyrics at once and still return the updated song to graphql

Answer 1

Fair point. Instead of doing findById() then it's probably better to use findByIdAndUpdate() instead, and also do the creation inline and "chain" the Promise instead:
SongSchema.statics.addLyrics = function(songId, lyrics) {
const Lyric = mongoose.model('lyric');
return Lyric.insertMany(lyrics).then( lyrics =>
this.findByIdAndUpdate(
songId,
{ "$push": { "lyrics": { "$each": lyrics } } },
{ "new": true }
);
};
That uses $each as a modifier to $push which accepts and array and does an "atomic" operation to update the document. It's a lot more efficient and safer than fetching the document "then" modifying it before updating back.
Also of course insertMany() does your 'array' of lyrics as a single write as opposed to "many".
An alternate approach would be to create instances based on a Array.map() and save() in parallel.
SongSchema.statics.addLyrics = function(songId, lyrics) {
const Lyric = mongoose.model('lyric');
lyrics = lyrics.map(lyric => new Lyric(lyric));
return Promise.all([
this.findByIdAndUpdate(
songId,
{ "$push": { "lyrics": { "$each": lyrics } } },
{ "new": true }
),
...lyrics.map(lyric => lyric.save())
]).then(([song, ...lyrics]) => song);
};
But the first approach really has less overhead, and Promise.all() is not going to respond until "all" promises are resolved anyway. So you really don't gain anything by not doing the operations in series.
The alternate case of course is to instead of keeping an "array" of related ObjectId values within the Song, you would instead simply record the songId within the Lyric entry.
So the schema would then become something like:
const lyricSchema = new Schema({
title: String,
content: String,
songId: { type: Schema.Types.ObjectId, ref: 'Song' }
})
Then the insertion is simply
lyricSchema.statics.addLyrics = function(songId, lyrics) {
return this.insertMany(lyrics.map(lyric => ({ ...lyric, songId })))
}
And in the Song schema, instead of keeping an array like this:
songs: [{ type: Schema.Types.ObjectId, ref: 'Lyric' }]
Remove that and replace with a virtual,
SongSchema.virtual.('songs', {
ref: 'Lyric',
localField: '_id',
foreignField: 'songId'
});
And that means there is no need to touch the Song model at all as you can simply insert the related data without needing to update an array.
Modern MongoDB versions really should be using $lookup to "query" this information anyway, and the maintaining of "arrays" within a parent is a bit of an "anti-pattern" which generally should be avoided.
The "virtual" is therefore "optional", and just a way to enable populate() as a convenience.

Answer 2

The best way I know of is like this:
lyrics = lyrics.map((lyric. i) => {lyric, songId: songI[i]});
SongSchema.collection.insertMany(lyrics, {'ordered': false},
(err, data) => {
/*Do your stuff*/
});
Ordered true will throw an error if there is any repeated unique values and stop, if false, the error is still thrown but the insertion goes on for the non repeated ones.
You do not need to create a new Schema, but this way Momgoose validations will be skipped too.