Function _bulkWrite

lib/model.js:3421–3560

(ops, options)

};

async function _bulkWrite(ops, options) {
  options = options || {};
  const preFilter = buildMiddlewareFilter(options, 'pre');
  const postFilter = buildMiddlewareFilter(options, 'post');

  try {
    [ops, options] = await this.hooks.execPre('bulkWrite', this, [ops, options], { filter: preFilter });
  } catch (err) {
    if (err instanceof Kareem.skipWrappedFunction) {
      ops = err;
    } else {
      await this.hooks.execPost('bulkWrite', this, [null], { error: err, filter: postFilter });
    }
  }

  if (ops instanceof Kareem.skipWrappedFunction) {
    return ops.args[0];
  }

  const ordered = options.ordered == null ? true : options.ordered;

  if (ops.length === 0) {
    const BulkWriteResult = this.base.driver.get().BulkWriteResult;
    const bulkWriteResult = new BulkWriteResult(getDefaultBulkwriteResult(), false);
    bulkWriteResult.n = 0;
    decorateBulkWriteResult(bulkWriteResult, [], []);
    return bulkWriteResult;
  }

  const validations = options?._skipCastBulkWrite ? [] : ops.map(op => castBulkWrite(this, op, options));
  const asyncLocalStorage = this.db.base.transactionAsyncLocalStorage?.getStore();
  if ((!options || !Object.hasOwn(options, 'session')) && asyncLocalStorage?.session != null) {
    options = { ...options, session: asyncLocalStorage.session };
  }

  let res = null;
  if (ordered) {
    await new Promise((resolve, reject) => {
      each(validations, (fn, cb) => fn(cb), error => {
        if (error) {
          return reject(error);
        }

        resolve();
      });
    });

    try {
      res = await this.$__collection.bulkWrite(ops, options);
    } catch (error) {
      await this.hooks.execPost('bulkWrite', this, [null], { error, filter: postFilter });
    }
  } else {
    let validOpIndexes = [];
    let validationErrors = [];
    const results = [];
    if (validations.length > 0) {
      validOpIndexes = await Promise.all(ops.map((op, i) => {