refactor(NODE-3337): unwrap WriteConcernError

src/bulk/common.ts

@@ -26,7 +26,10 @@ import type { Collection } from '../collection';
 import type { Topology } from '../sdam/topology';
 import type { CommandOperationOptions, CollationOptions } from '../operations/command';
 import type { Hint } from '../operations/operation';
-import type { Filter, OptionalId, UpdateFilter } from '../mongo_types';
+import type { Filter, OneOrMore, OptionalId, UpdateFilter } from '../mongo_types';
+
+/** @internal */
+const kServerError = Symbol('serverError');
 
 /** @public */
 export const BatchType = Object.freeze({
@@ -309,9 +312,7 @@ export class BulkWriteResult {
         if (i === 0) errmsg = errmsg + ' and ';
       }
 
-      return new WriteConcernError(
-        new MongoServerError({ errmsg: errmsg, code: MONGODB_ERROR_CODES.WriteConcernFailed })
-      );
+      return new WriteConcernError({ errmsg, code: MONGODB_ERROR_CODES.WriteConcernFailed });
     }
   }
 
@@ -328,34 +329,52 @@ export class BulkWriteResult {
   }
 }
 
+/** @public */
+export interface WriteConcernErrorData {
+  code: number;
+  errmsg: string;
+  errInfo?: Document;
+}
+
 /**
  * An error representing a failure by the server to apply the requested write concern to the bulk operation.
  * @public
  * @category Error
  */
 export class WriteConcernError {
-  err: MongoServerError;
+  /** @internal */
+  [kServerError]: WriteConcernErrorData;
 
-  constructor(err: MongoServerError) {
-    this.err = err;
+  constructor(error: WriteConcernErrorData) {
+    this[kServerError] = error;
   }
 
   /** Write concern error code. */
   get code(): number | undefined {
-    return this.err.code;
+    return this[kServerError].code;
   }
 
   /** Write concern error message. */
-  get errmsg(): string {
-    return this.err.errmsg;
+  get errmsg(): string | undefined {
+    return this[kServerError].errmsg;
+  }
+
+  /** Write concern error info. */
+  get errInfo(): Document | undefined {
+    return this[kServerError].errInfo;
+  }
+
+  /** @deprecated The `err` prop that contained a MongoServerError has been deprecated. */
+  get err(): WriteConcernErrorData {
+    return this[kServerError];
   }
 
-  toJSON(): { code?: number; errmsg: string } {
-    return { code: this.err.code, errmsg: this.err.errmsg };
+  toJSON(): WriteConcernErrorData {
+    return this[kServerError];
   }
 
   toString(): string {
-    return `WriteConcernError(${this.err.errmsg})`;
+    return `WriteConcernError(${this.errmsg})`;
   }
 }
 
@@ -656,17 +675,12 @@ function handleMongoWriteConcernError(
 ) {
   mergeBatchResults(batch, bulkResult, undefined, err.result);
 
-  // TODO: Remove multiple levels of wrapping (NODE-3337)
-  const wrappedWriteConcernError = new WriteConcernError(
-    new MongoServerError({
-      errmsg: err.result?.writeConcernError.errmsg,
-      code: err.result?.writeConcernError.result
-    })
-  );
-
   callback(
     new MongoBulkWriteError(
-      new MongoServerError(wrappedWriteConcernError),
+      {
+        message: err.result?.writeConcernError.errmsg,
+        code: err.result?.writeConcernError.result
+      },
       new BulkWriteResult(bulkResult)
     )
   );
@@ -679,13 +693,28 @@ function handleMongoWriteConcernError(
  */
 export class MongoBulkWriteError extends MongoServerError {
   result: BulkWriteResult;
+  writeErrors: OneOrMore<WriteError> = [];
+  err?: WriteConcernError;
 
   /** Creates a new MongoBulkWriteError */
-  constructor(error: AnyError, result: BulkWriteResult) {
-    super(error as Error);
-    Object.assign(this, error);
+  constructor(
+    error:
+      | { message: string; code: number; writeErrors?: WriteError[] }
+      | WriteConcernError
+      | AnyError,
+    result: BulkWriteResult
+  ) {
+    super(error);
+
+    if (error instanceof WriteConcernError) this.err = error;
+    else if (!(error instanceof Error)) {
+      this.message = error.message;
+      this.code = error.code;
+      this.writeErrors = error.writeErrors ?? [];
+    }
 
     this.result = result;
+    Object.assign(this, error);
   }
 
   get name(): string {
@@ -1225,11 +1254,11 @@ export abstract class BulkOperationBase {
 
       callback(
         new MongoBulkWriteError(
-          new MongoServerError({
+          {
             message: msg,
             code: this.s.bulkResult.writeErrors[0].code,
             writeErrors: this.s.bulkResult.writeErrors
-          }),
+          },
           writeResult
         )
       );
@@ -1239,7 +1268,7 @@ export abstract class BulkOperationBase {
 
     const writeConcernError = writeResult.getWriteConcernError();
     if (writeConcernError) {
-      callback(new MongoBulkWriteError(new MongoServerError(writeConcernError), writeResult));
+      callback(new MongoBulkWriteError(writeConcernError, writeResult));
       return true;
     }
   }

src/error.ts

@@ -60,12 +60,12 @@ export const GET_MORE_RESUMABLE_CODES = new Set<number>([
 ]);
 
 /** @public */
-export interface ErrorDescription {
+export interface ErrorDescription extends Document {
   message?: string;
   errmsg?: string;
   $err?: string;
   errorLabels?: string[];
-  [key: string]: any;
+  errInfo?: Document;
 }
 
 /**
@@ -84,7 +84,6 @@ export class MongoError extends Error {
   constructor(message: string | Error) {
     if (message instanceof Error) {
       super(message.message);
-      this.stack = message.stack;
     } else {
       super(message);
     }
@@ -136,23 +135,20 @@ export class MongoServerError extends MongoError {
   code?: number;
   codeName?: string;
   writeConcernError?: Document;
+  errInfo?: Document;
+  ok?: number;
+  topologyVersion?: TopologyVersion;
+  [key: string]: any;
 
-  constructor(message: Error | ErrorDescription) {
-    if (message instanceof Error) {
-      super(message);
-    } else {
-      super(message.message || message.errmsg || message.$err || 'n/a');
-      if (message.errorLabels) {
-        this[kErrorLabels] = new Set(message.errorLabels);
-      }
-
-      for (const name in message) {
-        if (name === 'errorLabels' || name === 'errmsg' || name === 'message') {
-          continue;
-        }
-
-        (this as any)[name] = message[name];
-      }
+  constructor(message: ErrorDescription) {
+    super(message.message || message.errmsg || message.$err || 'n/a');
+    if (message.errorLabels) {
+      this[kErrorLabels] = new Set(message.errorLabels);
+    }
+
+    for (const name in message) {
+      if (name !== 'errorLabels' && name !== 'errmsg' && name !== 'message')
+        this[name] = message[name];
     }
   }
 
@@ -682,13 +678,15 @@ function makeWriteConcernResultObject(input: any) {
 export class MongoWriteConcernError extends MongoServerError {
   /** The result document (provided if ok: 1) */
   result?: Document;
+  errInfo?: Document;
 
-  constructor(message: ErrorDescription, result: Document) {
+  constructor(message: ErrorDescription, result?: Document) {
     if (result && Array.isArray(result.errorLabels)) {
       message.errorLabels = result.errorLabels;
     }
 
     super(message);
+    this.errInfo = message.errInfo;
 
     if (result != null) {
       this.result = makeWriteConcernResultObject(result);

src/index.ts

@@ -360,7 +360,13 @@ export type {
 export type { W, WriteConcernOptions, WriteConcernSettings } from './write_concern';
 export type { ExecutionResult } from './operations/execute_operation';
 export type { InternalAbstractCursorOptions } from './cursor/abstract_cursor';
-export type { BulkOperationBase, BulkOperationPrivate, FindOperators, Batch } from './bulk/common';
+export type {
+  BulkOperationBase,
+  BulkOperationPrivate,
+  FindOperators,
+  Batch,
+  WriteConcernErrorData
+} from './bulk/common';
 export type { OrderedBulkOperation } from './bulk/ordered';
 export type { UnorderedBulkOperation } from './bulk/unordered';
 export type { Encrypter, EncrypterOptions } from './encrypter';

src/operations/insert.ts

@@ -70,7 +70,10 @@ export class InsertOneOperation extends InsertOperation {
     super.execute(server, session, (err, res) => {
       if (err || res == null) return callback(err);
       if (res.code) return callback(new MongoServerError(res));
-      if (res.writeErrors) return callback(new MongoServerError(res.writeErrors[0]));
+      if (res.writeErrors) {
+        // This should be a WriteError but we can't change it now because of error hierarchy
+        return callback(new MongoServerError(res.writeErrors[0]));
+      }
 
       callback(undefined, {
         acknowledged: this.writeConcern?.w !== 0 ?? true,

test/unit/core/write_concern_error.test.js

@@ -2,11 +2,10 @@
 const { Topology } = require('../../../src/sdam/topology');
 const mock = require('../../tools/mock');
 const { ReplSetFixture } = require('./common');
-const { MongoWriteConcernError } = require('../../../src/error');
+const { MongoServerError, MongoWriteConcernError } = require('../../../src/error');
 const { expect } = require('chai');
 const { ns } = require('../../../src/utils');
 const { once } = require('events');
-const { MongoServerError } = require('../../../src');
 
 describe('WriteConcernError', function () {
   let test;