mongodb 4.0.0 → 4.1.2

package/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;
 }
 
 /**
@@ -78,13 +78,17 @@ export interface ErrorDescription {
 export class MongoError extends Error {
   /** @internal */
   [kErrorLabels]: Set<string>;
+  /**
+   * This is a number in MongoServerError and a string in MongoDriverError
+   * @privateRemarks
+   * Define the type override on the subclasses when we can use the override keyword
+   */
   code?: number | string;
   topologyVersion?: TopologyVersion;
 
   constructor(message: string | Error) {
     if (message instanceof Error) {
       super(message.message);
-      this.stack = message.stack;
     } else {
       super(message);
     }
@@ -133,26 +137,21 @@ export class MongoError extends Error {
  * @category Error
  */
 export class MongoServerError extends MongoError {
-  code?: number;
   codeName?: string;
   writeConcernError?: Document;
+  errInfo?: Document;
+  ok?: number;
+  [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];
     }
   }
 
@@ -168,7 +167,6 @@ export class MongoServerError extends MongoError {
  * @category Error
  */
 export class MongoDriverError extends MongoError {
-  code?: string;
   constructor(message: string) {
     super(message);
   }
@@ -178,6 +176,26 @@ export class MongoDriverError extends MongoError {
   }
 }
 
+/**
+ * An error generated when the driver API is used incorrectly
+ *
+ * @privateRemarks
+ * Should **never** be directly instantiated
+ *
+ * @public
+ * @category Error
+ */
+
+export class MongoAPIError extends MongoDriverError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoAPIError';
+  }
+}
+
 /**
  * An error generated when the driver encounters unexpected input
  * or reaches an unexpected/invalid internal state
@@ -189,7 +207,7 @@ export class MongoDriverError extends MongoError {
  * @category Error
  */
 export class MongoRuntimeError extends MongoDriverError {
-  protected constructor(message: string) {
+  constructor(message: string) {
     super(message);
   }
 
@@ -202,17 +220,33 @@ export class MongoRuntimeError extends MongoDriverError {
  * An error generated when a batch command is reexecuted after one of the commands in the batch
  * has failed
  *
+ * @public
+ * @category Error
+ */
+export class MongoBatchReExecutionError extends MongoAPIError {
+  constructor(message = 'This batch has already been executed, create new batch to execute') {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoBatchReExecutionError';
+  }
+}
+
+/**
+ * An error generated when the driver fails to decompress
+ * data received from the server.
  *
  * @public
  * @category Error
  */
-export class MongoBatchReExecutionError extends MongoRuntimeError {
+export class MongoDecompressionError extends MongoRuntimeError {
   constructor(message: string) {
     super(message);
   }
 
   get name(): string {
-    return 'MongoBatchReExecutionError';
+    return 'MongoDecompressionError';
   }
 }
 
@@ -220,11 +254,10 @@ export class MongoBatchReExecutionError extends MongoRuntimeError {
  * An error thrown when the user attempts to operate on a database or collection through a MongoClient
  * that has not yet successfully called the "connect" method
  *
- *
  * @public
  * @category Error
  */
-export class MongoNotConnectedError extends MongoRuntimeError {
+export class MongoNotConnectedError extends MongoAPIError {
   constructor(message: string) {
     super(message);
   }
@@ -235,37 +268,117 @@ export class MongoNotConnectedError extends MongoRuntimeError {
 }
 
 /**
- * An error thrown when the user attempts to operate on a cursor that is in a state which does not
- * support the attempted operation.
+ * An error generated when the user makes a mistake in the usage of transactions.
+ * (e.g. attempting to commit a transaction with a readPreference other than primary)
  *
+ * @public
+ * @category Error
+ */
+export class MongoTransactionError extends MongoAPIError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoTransactionError';
+  }
+}
+
+/**
+ * An error generated when the user attempts to operate
+ * on a session that has expired or has been closed.
+ *
+ * @public
+ * @category Error
+ */
+export class MongoExpiredSessionError extends MongoAPIError {
+  constructor(message = 'Cannot use a session that has ended') {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoExpiredSessionError';
+  }
+}
+
+/**
+ * A error generated when the user attempts to authenticate
+ * via Kerberos, but fails to connect to the Kerberos client.
+ *
+ * @public
+ * @category Error
+ */
+export class MongoKerberosError extends MongoRuntimeError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoKerberosError';
+  }
+}
+
+/**
+ * An error generated when a ChangeStream operation fails to execute.
  *
  * @public
  * @category Error
  */
-export class MongoCursorError extends MongoRuntimeError {
+export class MongoChangeStreamError extends MongoRuntimeError {
   constructor(message: string) {
     super(message);
   }
 
   get name(): string {
-    return 'MongoCursorError';
+    return 'MongoChangeStreamError';
   }
 }
 
 /**
  * An error thrown when the user calls a function or method not supported on a tailable cursor
  *
+ * @public
+ * @category Error
+ */
+export class MongoTailableCursorError extends MongoAPIError {
+  constructor(message = 'Tailable cursor does not support this operation') {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoTailableCursorError';
+  }
+}
+
+/** An error generated when a GridFSStream operation fails to execute.
  *
  * @public
  * @category Error
  */
-export class MongoTailableCursorError extends MongoCursorError {
+export class MongoGridFSStreamError extends MongoRuntimeError {
   constructor(message: string) {
     super(message);
   }
 
   get name(): string {
-    return 'MongoTailableCursorError';
+    return 'MongoGridFSStreamError';
+  }
+}
+
+/**
+ * An error generated when a malformed or invalid chunk is
+ * encountered when reading from a GridFSStream.
+ *
+ * @public
+ * @category Error
+ */
+export class MongoGridFSChunkError extends MongoRuntimeError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoGridFSChunkError';
   }
 }
 
@@ -273,12 +386,11 @@ export class MongoTailableCursorError extends MongoCursorError {
  * An error thrown when the user attempts to add options to a cursor that has already been
  * initialized
  *
- *
  * @public
  * @category Error
  */
-export class MongoCursorInUseError extends MongoCursorError {
-  constructor(message: string) {
+export class MongoCursorInUseError extends MongoAPIError {
+  constructor(message = 'Cursor is already initialized') {
     super(message);
   }
 
@@ -287,20 +399,53 @@ export class MongoCursorInUseError extends MongoCursorError {
   }
 }
 
+/**
+ * An error generated when an attempt is made to operate
+ * on a closed/closing server.
+ *
+ * @public
+ * @category Error
+ */
+export class MongoServerClosedError extends MongoAPIError {
+  constructor(message = 'Server is closed') {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoServerClosedError';
+  }
+}
+
 /**
  * An error thrown when an attempt is made to read from a cursor that has been exhausted
  *
+ * @public
+ * @category Error
+ */
+export class MongoCursorExhaustedError extends MongoAPIError {
+  constructor(message?: string) {
+    super(message || 'Cursor is exhausted');
+  }
+
+  get name(): string {
+    return 'MongoCursorExhaustedError';
+  }
+}
+
+/**
+ * An error generated when an attempt is made to operate on a
+ * dropped, or otherwise unavailable, database.
  *
  * @public
  * @category Error
  */
-export class MongoCursorExhaustedError extends MongoCursorError {
-  constructor(message: string) {
+export class MongoTopologyClosedError extends MongoAPIError {
+  constructor(message = 'Topology is closed') {
     super(message);
   }
 
   get name(): string {
-    return 'MongoCursorExhaustedError';
+    return 'MongoTopologyClosedError';
   }
 }
 
@@ -310,6 +455,12 @@ export function isNetworkErrorBeforeHandshake(err: MongoNetworkError): boolean {
   return err[kBeforeHandshake] === true;
 }
 
+/** @public */
+export interface MongoNetworkErrorOptions {
+  /** Indicates the timeout happened before a connection handshake completed */
+  beforeHandshake: boolean;
+}
+
 /**
  * An error indicating an issue with the network, including TCP errors and timeouts.
  * @public
@@ -319,7 +470,7 @@ export class MongoNetworkError extends MongoError {
   /** @internal */
   [kBeforeHandshake]?: boolean;
 
-  constructor(message: string | Error, options?: { beforeHandshake?: boolean }) {
+  constructor(message: string | Error, options?: MongoNetworkErrorOptions) {
     super(message);
 
     if (options && typeof options.beforeHandshake === 'boolean') {
@@ -332,12 +483,6 @@ export class MongoNetworkError extends MongoError {
   }
 }
 
-/** @public */
-export interface MongoNetworkTimeoutErrorOptions {
-  /** Indicates the timeout happened before a connection handshake completed */
-  beforeHandshake: boolean;
-}
-
 /**
  * An error indicating a network timeout occurred
  * @public
@@ -347,7 +492,7 @@ export interface MongoNetworkTimeoutErrorOptions {
  * CSFLE has a dependency on this error with an instanceof check
  */
 export class MongoNetworkTimeoutError extends MongoNetworkError {
-  constructor(message: string, options?: MongoNetworkTimeoutErrorOptions) {
+  constructor(message: string, options?: MongoNetworkErrorOptions) {
     super(message, options);
   }
 
@@ -371,6 +516,75 @@ export class MongoParseError extends MongoDriverError {
   }
 }
 
+/**
+ * An error generated when the user supplies malformed or unexpected arguments
+ * or when a required argument or field is not provided.
+ *
+ *
+ * @public
+ * @category Error
+ */
+export class MongoInvalidArgumentError extends MongoAPIError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoInvalidArgumentError';
+  }
+}
+
+/**
+ * An error generated when a feature that is not enabled or allowed for the current server
+ * configuration is used
+ *
+ *
+ * @public
+ * @category Error
+ */
+export class MongoCompatibilityError extends MongoAPIError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoCompatibilityError';
+  }
+}
+
+/**
+ * An error generated when the user fails to provide authentication credentials before attempting
+ * to connect to a mongo server instance.
+ *
+ *
+ * @public
+ * @category Error
+ */
+export class MongoMissingCredentialsError extends MongoAPIError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoMissingCredentialsError';
+  }
+}
+
+/**
+ * An error generated when a required module or dependency is not present in the local environment
+ *
+ * @public
+ * @category Error
+ */
+export class MongoMissingDependencyError extends MongoAPIError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  get name(): string {
+    return 'MongoMissingDependencyError';
+  }
+}
 /**
  * An error signifying a general system issue
  * @public
@@ -433,13 +647,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);
@@ -582,7 +798,7 @@ export function isResumableError(error?: MongoError, wireVersion?: number): bool
     return true;
   }
 
-  if (typeof wireVersion !== 'undefined' && wireVersion >= 9) {
+  if (wireVersion != null && wireVersion >= 9) {
     // DRIVERS-1308: For 4.4 drivers running against 4.4 servers, drivers will add a special case to treat the CursorNotFound error code as resumable
     if (error && error instanceof MongoError && error.code === 43) {
       return true;

package/src/explain.ts

@@ -1,4 +1,4 @@
-import { MongoDriverError } from './error';
+import { MongoInvalidArgumentError } from './error';
 
 /** @public */
 export const ExplainVerbosity = Object.freeze({
@@ -40,13 +40,13 @@ export class Explain {
   }
 
   static fromOptions(options?: ExplainOptions): Explain | undefined {
-    if (options?.explain === undefined) return;
+    if (options?.explain == null) return;
 
     const explain = options.explain;
     if (typeof explain === 'boolean' || typeof explain === 'string') {
       return new Explain(explain);
     }
 
-    throw new MongoDriverError('explain must be a string or a boolean');
+    throw new MongoInvalidArgumentError('Field "explain" must be a string or a boolean');
   }
 }