mongodb 4.3.1 → 4.5.0

package/src/operations/indexes.ts

@@ -24,7 +24,6 @@ import { indexInformation, IndexInformationOptions } from './common_functions';
 import { executeOperation, ExecutionResult } from './execute_operation';
 import { AbstractOperation, Aspect, defineAspects } from './operation';
 
-const LIST_INDEXES_WIRE_VERSION = 3;
 const VALID_INDEX_OPTIONS = new Set([
   'background',
   'unique',
@@ -160,7 +159,7 @@ function makeIndexSpec(indexSpec: IndexSpecification, options: any): IndexDescri
 
 /** @internal */
 export class IndexesOperation extends AbstractOperation<Document[]> {
-  options: IndexInformationOptions;
+  override options: IndexInformationOptions;
   collection: Collection;
 
   constructor(collection: Collection, options: IndexInformationOptions) {
@@ -169,7 +168,11 @@ export class IndexesOperation extends AbstractOperation<Document[]> {
     this.collection = collection;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document[]>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document[]>
+  ): void {
     const coll = this.collection;
     const options = this.options;
 
@@ -186,7 +189,7 @@ export class IndexesOperation extends AbstractOperation<Document[]> {
 export class CreateIndexesOperation<
   T extends string | string[] = string[]
 > extends CommandOperation<T> {
-  options: CreateIndexesOptions;
+  override options: CreateIndexesOptions;
   collectionName: string;
   indexes: IndexDescription[];
 
@@ -204,7 +207,11 @@ export class CreateIndexesOperation<
     this.indexes = indexes;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<T>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<T>
+  ): void {
     const options = this.options;
     const indexes = this.indexes;
 
@@ -280,7 +287,11 @@ export class CreateIndexOperation extends CreateIndexesOperation<string> {
 
     super(parent, collectionName, [makeIndexSpec(indexSpec, options)], options);
   }
-  execute(server: Server, session: ClientSession, callback: Callback<string>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<string>
+  ): void {
     super.execute(server, session, (err, indexNames) => {
       if (err || !indexNames) return callback(err);
       return callback(undefined, indexNames[0]);
@@ -291,7 +302,6 @@ export class CreateIndexOperation extends CreateIndexesOperation<string> {
 /** @internal */
 export class EnsureIndexOperation extends CreateIndexOperation {
   db: Db;
-  collectionName: string;
 
   constructor(
     db: Db,
@@ -306,7 +316,7 @@ export class EnsureIndexOperation extends CreateIndexOperation {
     this.collectionName = collectionName;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback): void {
+  override execute(server: Server, session: ClientSession | undefined, callback: Callback): void {
     const indexName = this.indexes[0].name;
     const cursor = this.db.collection(this.collectionName).listIndexes({ session });
     cursor.toArray((err, indexes) => {
@@ -333,7 +343,7 @@ export type DropIndexesOptions = CommandOperationOptions;
 
 /** @internal */
 export class DropIndexOperation extends CommandOperation<Document> {
-  options: DropIndexesOptions;
+  override options: DropIndexesOptions;
   collection: Collection;
   indexName: string;
 
@@ -345,7 +355,11 @@ export class DropIndexOperation extends CommandOperation<Document> {
     this.indexName = indexName;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const cmd = { dropIndexes: this.collection.collectionName, index: this.indexName };
     super.executeCommand(server, session, cmd, callback);
   }
@@ -357,7 +371,7 @@ export class DropIndexesOperation extends DropIndexOperation {
     super(collection, '*', options);
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback): void {
+  override execute(server: Server, session: ClientSession | undefined, callback: Callback): void {
     super.execute(server, session, err => {
       if (err) return callback(err, false);
       callback(undefined, true);
@@ -373,7 +387,7 @@ export interface ListIndexesOptions extends CommandOperationOptions {
 
 /** @internal */
 export class ListIndexesOperation extends CommandOperation<Document> {
-  options: ListIndexesOptions;
+  override options: ListIndexesOptions;
   collectionNamespace: MongoDBNamespace;
 
   constructor(collection: Collection, options?: ListIndexesOptions) {
@@ -383,28 +397,24 @@ export class ListIndexesOperation extends CommandOperation<Document> {
     this.collectionNamespace = collection.s.namespace;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const serverWireVersion = maxWireVersion(server);
-    if (serverWireVersion < LIST_INDEXES_WIRE_VERSION) {
-      const systemIndexesNS = this.collectionNamespace.withCollection('system.indexes');
-      const collectionNS = this.collectionNamespace.toString();
-
-      server.query(
-        systemIndexesNS,
-        { query: { ns: collectionNS } },
-        { ...this.options, readPreference: this.readPreference },
-        callback
-      );
-      return;
-    }
 
     const cursor = this.options.batchSize ? { batchSize: this.options.batchSize } : {};
-    super.executeCommand(
-      server,
-      session,
-      { listIndexes: this.collectionNamespace.collection, cursor },
-      callback
-    );
+
+    const command: Document = { listIndexes: this.collectionNamespace.collection, cursor };
+
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (serverWireVersion >= 9 && this.options.comment !== undefined) {
+      command.comment = this.options.comment;
+    }
+
+    super.executeCommand(server, session, command, callback);
   }
 }
 
@@ -434,7 +444,7 @@ export class ListIndexesCursor extends AbstractCursor {
       session
     });
 
-    executeOperation(getTopology(this.parent), operation, (err, response) => {
+    executeOperation(this.parent, operation, (err, response) => {
       if (err || response == null) return callback(err);
 
       // TODO: NODE-2882
@@ -445,7 +455,7 @@ export class ListIndexesCursor extends AbstractCursor {
 
 /** @internal */
 export class IndexExistsOperation extends AbstractOperation<boolean> {
-  options: IndexInformationOptions;
+  override options: IndexInformationOptions;
   collection: Collection;
   indexes: string | string[];
 
@@ -460,7 +470,11 @@ export class IndexExistsOperation extends AbstractOperation<boolean> {
     this.indexes = indexes;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<boolean>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<boolean>
+  ): void {
     const coll = this.collection;
     const indexes = this.indexes;
 
@@ -489,7 +503,7 @@ export class IndexExistsOperation extends AbstractOperation<boolean> {
 
 /** @internal */
 export class IndexInformationOperation extends AbstractOperation<Document> {
-  options: IndexInformationOptions;
+  override options: IndexInformationOptions;
   db: Db;
   name: string;
 
@@ -500,7 +514,11 @@ export class IndexInformationOperation extends AbstractOperation<Document> {
     this.name = name;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const db = this.db;
     const name = this.name;
 

package/src/operations/insert.ts

@@ -14,7 +14,7 @@ import { AbstractOperation, Aspect, defineAspects } from './operation';
 
 /** @internal */
 export class InsertOperation extends CommandOperation<Document> {
-  options: BulkWriteOptions;
+  override options: BulkWriteOptions;
   documents: Document[];
 
   constructor(ns: MongoDBNamespace, documents: Document[], options: BulkWriteOptions) {
@@ -24,7 +24,11 @@ export class InsertOperation extends CommandOperation<Document> {
     this.documents = documents;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const options = this.options ?? {};
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
     const command: Document = {
@@ -37,7 +41,9 @@ export class InsertOperation extends CommandOperation<Document> {
       command.bypassDocumentValidation = options.bypassDocumentValidation;
     }
 
-    if (options.comment != null) {
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
       command.comment = options.comment;
     }
 
@@ -66,7 +72,11 @@ export class InsertOneOperation extends InsertOperation {
     super(collection.s.namespace, prepareDocs(collection, [doc], options), options);
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<InsertOneResult>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<InsertOneResult>
+  ): void {
     super.execute(server, session, (err, res) => {
       if (err || res == null) return callback(err);
       if (res.code) return callback(new MongoServerError(res));
@@ -95,7 +105,7 @@ export interface InsertManyResult<TSchema = Document> {
 
 /** @internal */
 export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
-  options: BulkWriteOptions;
+  override options: BulkWriteOptions;
   collection: Collection;
   docs: Document[];
 
@@ -111,7 +121,11 @@ export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
     this.docs = docs;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<InsertManyResult>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<InsertManyResult>
+  ): void {
     const coll = this.collection;
     const options = { ...this.options, ...this.bsonOptions, readPreference: this.readPreference };
     const writeConcern = WriteConcern.fromOptions(options);

package/src/operations/is_capped.ts

@@ -7,7 +7,7 @@ import { AbstractOperation, OperationOptions } from './operation';
 
 /** @internal */
 export class IsCappedOperation extends AbstractOperation<boolean> {
-  options: OperationOptions;
+  override options: OperationOptions;
   collection: Collection;
 
   constructor(collection: Collection, options: OperationOptions) {
@@ -16,7 +16,11 @@ export class IsCappedOperation extends AbstractOperation<boolean> {
     this.collection = collection;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<boolean>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<boolean>
+  ): void {
     const coll = this.collection;
 
     coll.s.db

package/src/operations/list_collections.ts

@@ -1,16 +1,13 @@
 import type { Binary, Document } from '../bson';
-import * as CONSTANTS from '../constants';
 import { AbstractCursor } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { Callback, getTopology, maxWireVersion, MongoDBNamespace } from '../utils';
+import { Callback, getTopology, maxWireVersion } from '../utils';
 import { CommandOperation, CommandOperationOptions } from './command';
 import { executeOperation, ExecutionResult } from './execute_operation';
 import { Aspect, defineAspects } from './operation';
 
-const LIST_COLLECTIONS_WIRE_VERSION = 3;
-
 /** @public */
 export interface ListCollectionsOptions extends CommandOperationOptions {
   /** Since 4.0: If true, will only return the collection name in the response, and will omit additional info */
@@ -23,7 +20,7 @@ export interface ListCollectionsOptions extends CommandOperationOptions {
 
 /** @internal */
 export class ListCollectionsOperation extends CommandOperation<string[]> {
-  options: ListCollectionsOptions;
+  override options: ListCollectionsOptions;
   db: Db;
   filter: Document;
   nameOnly: boolean;
@@ -44,68 +41,36 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
     }
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<string[]>): void {
-    if (maxWireVersion(server) < LIST_COLLECTIONS_WIRE_VERSION) {
-      let filter = this.filter;
-      const databaseName = this.db.s.namespace.db;
-
-      // If we have legacy mode and have not provided a full db name filter it
-      if (typeof filter.name === 'string' && !new RegExp(`^${databaseName}\\.`).test(filter.name)) {
-        filter = Object.assign({}, filter);
-        filter.name = this.db.s.namespace.withCollection(filter.name).toString();
-      }
-
-      // No filter, filter by current database
-      if (filter == null) {
-        filter = { name: `/${databaseName}/` };
-      }
-
-      // Rewrite the filter to use $and to filter out indexes
-      if (filter.name) {
-        filter = { $and: [{ name: filter.name }, { name: /^((?!\$).)*$/ }] };
-      } else {
-        filter = { name: /^((?!\$).)*$/ };
-      }
-
-      const documentTransform = (doc: Document) => {
-        const matching = `${databaseName}.`;
-        const index = doc.name.indexOf(matching);
-        // Remove database name if available
-        if (doc.name && index === 0) {
-          doc.name = doc.name.substr(index + matching.length);
-        }
-
-        return doc;
-      };
-
-      server.query(
-        new MongoDBNamespace(databaseName, CONSTANTS.SYSTEM_NAMESPACE_COLLECTION),
-        { query: filter },
-        { batchSize: this.batchSize || 1000, readPreference: this.readPreference },
-        (err, result) => {
-          if (result && result.documents && Array.isArray(result.documents)) {
-            result.documents = result.documents.map(documentTransform);
-          }
-
-          callback(err, result);
-        }
-      );
-
-      return;
-    }
-
-    return super.executeCommand(server, session, this.generateCommand(), callback);
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<string[]>
+  ): void {
+    return super.executeCommand(
+      server,
+      session,
+      this.generateCommand(maxWireVersion(server)),
+      callback
+    );
   }
 
   /* This is here for the purpose of unit testing the final command that gets sent. */
-  generateCommand(): Document {
-    return {
+  generateCommand(wireVersion: number): Document {
+    const command: Document = {
       listCollections: 1,
       filter: this.filter,
       cursor: this.batchSize ? { batchSize: this.batchSize } : {},
       nameOnly: this.nameOnly,
       authorizedCollections: this.authorizedCollections
     };
+
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (wireVersion >= 9 && this.options.comment !== undefined) {
+      command.comment = this.options.comment;
+    }
+
+    return command;
   }
 }
 
@@ -153,7 +118,7 @@ export class ListCollectionsCursor<
       session
     });
 
-    executeOperation(getTopology(this.parent), operation, (err, response) => {
+    executeOperation(this.parent, operation, (err, response) => {
       if (err || response == null) return callback(err);
 
       // TODO: NODE-2882

package/src/operations/list_databases.ts

@@ -2,7 +2,7 @@ import type { Document } from '../bson';
 import type { Db } from '../db';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { Callback, MongoDBNamespace } from '../utils';
+import { Callback, maxWireVersion, MongoDBNamespace } from '../utils';
 import { CommandOperation, CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
@@ -26,7 +26,7 @@ export interface ListDatabasesOptions extends CommandOperationOptions {
 
 /** @internal */
 export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult> {
-  options: ListDatabasesOptions;
+  override options: ListDatabasesOptions;
 
   constructor(db: Db, options?: ListDatabasesOptions) {
     super(db, options);
@@ -34,7 +34,11 @@ export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<ListDatabasesResult>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<ListDatabasesResult>
+  ): void {
     const cmd: Document = { listDatabases: 1 };
     if (this.options.nameOnly) {
       cmd.nameOnly = Number(cmd.nameOnly);
@@ -48,6 +52,12 @@ export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult
       cmd.authorizedDatabases = this.options.authorizedDatabases;
     }
 
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (maxWireVersion(server) >= 9 && this.options.comment !== undefined) {
+      cmd.comment = this.options.comment;
+    }
+
     super.executeCommand(server, session, cmd, callback);
   }
 }

package/src/operations/map_reduce.ts

@@ -1,7 +1,6 @@
 import type { ObjectId } from '../bson';
 import { Code, Document } from '../bson';
 import type { Collection } from '../collection';
-import { Db } from '../db';
 import { MongoCompatibilityError, MongoServerError } from '../error';
 import { ReadPreference, ReadPreferenceMode } from '../read_preference';
 import type { Server } from '../sdam/server';
@@ -83,7 +82,7 @@ interface MapReduceStats {
  * @internal
  */
 export class MapReduceOperation extends CommandOperation<Document | Document[]> {
-  options: MapReduceOptions;
+  override options: MapReduceOptions;
   collection: Collection;
   /** The mapping function. */
   map: MapFunction | string;
@@ -112,7 +111,11 @@ export class MapReduceOperation extends CommandOperation<Document | Document[]>
     this.reduce = reduce;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document | Document[]>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document | Document[]>
+  ): void {
     const coll = this.collection;
     const map = this.map;
     const reduce = this.reduce;
@@ -206,9 +209,7 @@ export class MapReduceOperation extends CommandOperation<Document | Document[]>
       if (result.result != null && typeof result.result === 'object') {
         const doc = result.result;
         // Return a collection from another db
-        collection = new Db(coll.s.db.s.client, doc.db, coll.s.db.s.options).collection(
-          doc.collection
-        );
+        collection = coll.s.db.s.client.db(doc.db, coll.s.db.s.options).collection(doc.collection);
       } else {
         // Create a collection object that wraps the result collection
         collection = coll.s.db.collection(result.result);

package/src/operations/operation.ts

@@ -25,7 +25,7 @@ export interface OperationConstructor extends Function {
 export interface OperationOptions extends BSONSerializeOptions {
   /** Specify ClientSession for this command */
   session?: ClientSession;
-  willRetryWrites?: boolean;
+  willRetryWrite?: boolean;
 
   /** The preferred read preference (ReadPreference.primary, ReadPreference.primary_preferred, ReadPreference.secondary, ReadPreference.secondary_preferred, ReadPreference.nearest). */
   readPreference?: ReadPreferenceLike;
@@ -56,10 +56,9 @@ export abstract class AbstractOperation<TResult = any> {
   // BSON serialization options
   bsonOptions?: BSONSerializeOptions;
 
-  // TODO: Each operation defines its own options, there should be better typing here
-  options: Document;
+  options: OperationOptions;
 
-  [kSession]: ClientSession;
+  [kSession]: ClientSession | undefined;
 
   constructor(options: OperationOptions = {}) {
     this.readPreference = this.hasAspect(Aspect.WRITE_OPERATION)
@@ -69,16 +68,18 @@ export abstract class AbstractOperation<TResult = any> {
     // Pull the BSON serialize options from the already-resolved options
     this.bsonOptions = resolveBSONOptions(options);
 
-    if (options.session) {
-      this[kSession] = options.session;
-    }
+    this[kSession] = options.session != null ? options.session : undefined;
 
     this.options = options;
     this.bypassPinningCheck = !!options.bypassPinningCheck;
     this.trySecondaryWrite = false;
   }
 
-  abstract execute(server: Server, session: ClientSession, callback: Callback<TResult>): void;
+  abstract execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<TResult>
+  ): void;
 
   hasAspect(aspect: symbol): boolean {
     const ctor = this.constructor as OperationConstructor;
@@ -89,7 +90,7 @@ export abstract class AbstractOperation<TResult = any> {
     return ctor.aspects.has(aspect);
   }
 
-  get session(): ClientSession {
+  get session(): ClientSession | undefined {
     return this[kSession];
   }
 

package/src/operations/options_operation.ts

@@ -8,7 +8,7 @@ import { AbstractOperation, OperationOptions } from './operation';
 
 /** @internal */
 export class OptionsOperation extends AbstractOperation<Document> {
-  options: OperationOptions;
+  override options: OperationOptions;
   collection: Collection;
 
   constructor(collection: Collection, options: OperationOptions) {
@@ -17,7 +17,11 @@ export class OptionsOperation extends AbstractOperation<Document> {
     this.collection = collection;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const coll = this.collection;
 
     coll.s.db

package/src/operations/profiling_level.ts

@@ -10,14 +10,18 @@ export type ProfilingLevelOptions = CommandOperationOptions;
 
 /** @internal */
 export class ProfilingLevelOperation extends CommandOperation<string> {
-  options: ProfilingLevelOptions;
+  override options: ProfilingLevelOptions;
 
   constructor(db: Db, options: ProfilingLevelOptions) {
     super(db, options);
     this.options = options;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<string>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<string>
+  ): void {
     super.executeCommand(server, session, { profile: -1 }, (err, doc) => {
       if (err == null && doc.ok === 1) {
         const was = doc.was;

package/src/operations/remove_user.ts

@@ -10,7 +10,7 @@ export type RemoveUserOptions = CommandOperationOptions;
 
 /** @internal */
 export class RemoveUserOperation extends CommandOperation<boolean> {
-  options: RemoveUserOptions;
+  override options: RemoveUserOptions;
   username: string;
 
   constructor(db: Db, username: string, options: RemoveUserOptions) {
@@ -19,7 +19,11 @@ export class RemoveUserOperation extends CommandOperation<boolean> {
     this.username = username;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<boolean>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<boolean>
+  ): void {
     super.executeCommand(server, session, { dropUser: this.username }, err => {
       callback(err, err ? false : true);
     });

package/src/operations/rename.ts

@@ -18,7 +18,7 @@ export interface RenameOptions extends CommandOperationOptions {
 
 /** @internal */
 export class RenameOperation extends RunAdminCommandOperation {
-  options: RenameOptions;
+  override options: RenameOptions;
   collection: Collection;
   newName: string;
 
@@ -38,13 +38,17 @@ export class RenameOperation extends RunAdminCommandOperation {
     this.newName = newName;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Collection>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Collection>
+  ): void {
     const coll = this.collection;
 
     super.execute(server, session, (err, doc) => {
       if (err) return callback(err);
       // We have an error
-      if (doc.errmsg) {
+      if (doc?.errmsg) {
         return callback(new MongoServerError(doc));
       }