Model.create(doc, fn) should save all valid documents.

[danypype]

I'm trying to save a set of documents using Model.create(documents, function(error){...}) I found when a document is invalid, the previous documents were saved but the following will never be saved.

I think Model.create should save all valid documents. I would like an API like this.

//Passing one doc
Person.create({name: "John"}, function(error, john){...})

//Passing an array
var persons = [{name: "John"}, {name: "Doe"}];
Person.create(persons, function(errors, docs){...});

//Passing individual docs
Person.create({name: "John"}, {name: "Doe"}, function(errors, docs){...});

I would like to do a pull request, but first I want to know what do you think.

[nathanredblur]

yeap, I have the same problem.

[wbeckler]

Halleluja! Yes, this exactly!

[WhiteRavenPL]

Same here too.

[holisticode]

I have the same problem, but I vote for two APIs, one where it saves all or nothing, and one for all valid docs like requested above :)

[mahasooq]

Having the same problem here!

[lineus]

@vkarpov15 Model.create() does currently create all valid documents, but it returns only the first document that failed in the Error. Should/Can we change the behavior of Model.create() to collate all errors and return some sort of collection in the Error?

The following script shows that an error is generated and returned for the first duplicated doc, the rest of the duplicated ones fail silently and all unique docs are created.

7097.js

#!/usr/bin/env node
'use strict';

const assert = require('assert');
const mongoose = require('mongoose');
mongoose.set('useCreateIndex', true);
const { Schema, connection} = mongoose;
const DB = '7097';
const URI = `mongodb://localhost:27017/${DB}`;
const OPTS = { family: 4, useNewUrlParser: true };

const schema = new Schema({
  name: {
    type: String,
    unique: true
  }
}, { autoIndex: false });

const tests = '122344445667889'.split('').map(n => { return { name: `test${n}`};});
const compare = '123456789'.split('').map(d => `test${d}`);

const errors = [];
function error(e) {
  console.dir(e);
  errors.push(e.message);
}

async function run() {
  assert.strictEqual(mongoose.version, '5.3.1');
  await mongoose.connect(URI, OPTS);
  await connection.dropDatabase();
  const Test = mongoose.model('test', schema);
  await Test.createIndexes();
  await Test.create(tests).catch(error);

  let created = await Test.find({}).lean();
  assert.strictEqual(created.length, 9);
  assert.deepStrictEqual(created.map(d => d.name), compare);
  assert.strictEqual(errors.length, 1);
  assert.ok(/^E11000/.test(errors[0]));
  console.log('All Assertions Pass');
  await connection.close();
}

run().catch(e => { console.error(e); return connection.close();});

Output:

issues: ./7097.js
{ MongoError: E11000 duplicate key error index: 7097.tests.$name_1 dup key: { : "test2" }
    at Function.create (/Users/lineus/dev/node/mongoose/node_modules/mongodb-core/lib/error.js:43:12)
    at toError (/Users/lineus/dev/node/mongoose/node_modules/mongodb/lib/utils.js:149:22)
    at coll.s.topology.insert (/Users/lineus/dev/node/mongoose/node_modules/mongodb/lib/operations/collection_ops.js:827:39)
    at /Users/lineus/dev/node/mongoose/node_modules/mongodb-core/lib/connection/pool.js:532:18
    at process._tickCallback (internal/process/next_tick.js:61:11)
  driver: true,
  name: 'MongoError',
  index: 0,
  code: 11000,
  errmsg:
   'E11000 duplicate key error index: 7097.tests.$name_1 dup key: { : "test2" }',
  [Symbol(mongoErrorContextSymbol)]: {} }
All Assertions Pass
issues:

[vkarpov15]

@lineus we could just add a list of saved docs and a list of docs that failed to save in the error. Thoughts?

[lineus]

sounds good to me. I'll take a stab at it.

[vkarpov15]

#13544 adds an aggregateErrors option that should fix this one. Like @lineus mentioned, Model.create() does always create all valid documents, just without aggregateErrors option create() will throw the first error it gets, but it won't cancel the insertion of the other documents.