mongodb 4.7.0 → 4.8.0

package/src/cmap/connect.ts

@@ -8,7 +8,6 @@ import type { Document } from '../bson';
 import { Int32 } from '../bson';
 import { LEGACY_HELLO_COMMAND } from '../constants';
 import {
-  AnyError,
   MongoCompatibilityError,
   MongoError,
   MongoErrorLabel,
@@ -462,40 +461,36 @@ function makeSocks5Connection(options: MakeConnectionOptions, callback: Callback
       }
 
       // Then, establish the Socks5 proxy connection:
-      SocksClient.createConnection(
-        {
-          existing_socket: rawSocket,
-          timeout: options.connectTimeoutMS,
-          command: 'connect',
-          destination: {
-            host: destination.host,
-            port: destination.port
-          },
-          proxy: {
-            // host and port are ignored because we pass existing_socket
-            host: 'iLoveJavaScript',
-            port: 0,
-            type: 5,
-            userId: options.proxyUsername || undefined,
-            password: options.proxyPassword || undefined
-          }
+      SocksClient.createConnection({
+        existing_socket: rawSocket,
+        timeout: options.connectTimeoutMS,
+        command: 'connect',
+        destination: {
+          host: destination.host,
+          port: destination.port
         },
-        (err: AnyError, info: { socket: Stream }) => {
-          if (err) {
-            return callback(connectionFailureError('error', err));
-          }
-
+        proxy: {
+          // host and port are ignored because we pass existing_socket
+          host: 'iLoveJavaScript',
+          port: 0,
+          type: 5,
+          userId: options.proxyUsername || undefined,
+          password: options.proxyPassword || undefined
+        }
+      }).then(
+        ({ socket }) => {
           // Finally, now treat the resulting duplex stream as the
           // socket over which we send and receive wire protocol messages:
           makeConnection(
             {
               ...options,
-              existingSocket: info.socket,
+              existingSocket: socket,
               proxyHost: undefined
             },
             callback
           );
-        }
+        },
+        error => callback(connectionFailureError('error', error))
       );
     }
   );

package/src/cmap/connection.ts

@@ -533,7 +533,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
         clusterTime = session.clusterTime;
       }
 
-      const err = applySession(session, finalCmd, options as CommandOptions);
+      const err = applySession(session, finalCmd, options);
       if (err) {
         return callback(err);
       }
@@ -727,7 +727,6 @@ export class CryptoConnection extends Connection {
         callback(err, null);
         return;
       }
-
       super.command(ns, encrypted, options, (err, response) => {
         if (err || response == null) {
           callback(err, response);

package/src/cmap/wire_protocol/compression.ts

@@ -52,9 +52,10 @@ export function compress(
       if (Snappy[PKG_VERSION].major <= 6) {
         Snappy.compress(dataToBeCompressed, callback);
       } else {
-        Snappy.compress(dataToBeCompressed)
-          .then(buffer => callback(undefined, buffer))
-          .catch(error => callback(error));
+        Snappy.compress(dataToBeCompressed).then(
+          buffer => callback(undefined, buffer),
+          error => callback(error)
+        );
       }
       break;
     }
@@ -102,9 +103,10 @@ export function decompress(
       if (Snappy[PKG_VERSION].major <= 6) {
         Snappy.uncompress(compressedData, { asBuffer: true }, callback);
       } else {
-        Snappy.uncompress(compressedData, { asBuffer: true })
-          .then(buffer => callback(undefined, buffer))
-          .catch(error => callback(error));
+        Snappy.uncompress(compressedData, { asBuffer: true }).then(
+          buffer => callback(undefined, buffer),
+          error => callback(error)
+        );
       }
       break;
     }

package/src/collection.ts

@@ -5,6 +5,7 @@ import { UnorderedBulkOperation } from './bulk/unordered';
 import { ChangeStream, ChangeStreamDocument, ChangeStreamOptions } from './change_stream';
 import { AggregationCursor } from './cursor/aggregation_cursor';
 import { FindCursor } from './cursor/find_cursor';
+import { ListIndexesCursor } from './cursor/list_indexes_cursor';
 import type { Db } from './db';
 import { MongoInvalidArgumentError } from './error';
 import type { Logger, LoggerOptions } from './logger';
@@ -57,7 +58,6 @@ import {
   IndexExistsOperation,
   IndexInformationOperation,
   IndexSpecification,
-  ListIndexesCursor,
   ListIndexesOptions
 } from './operations/indexes';
 import {
@@ -725,7 +725,7 @@ export class Collection<TSchema extends Document = Document> {
     }
 
     if (typeof filter === 'function') {
-      callback = filter as Callback<WithId<TSchema> | null>;
+      callback = filter;
       filter = {};
       options = {};
     }
@@ -1128,7 +1128,7 @@ export class Collection<TSchema extends Document = Document> {
       this.s.db.s.client,
       new CountDocumentsOperation(
         this as TODO_NODE_3286,
-        filter as Document,
+        filter,
         resolveOptions(this, options as CountDocumentsOptions)
       ),
       callback
@@ -1191,7 +1191,7 @@ export class Collection<TSchema extends Document = Document> {
     callback?: Callback<any[]>
   ): Promise<any[]> | void {
     if (typeof filter === 'function') {
-      (callback = filter as Callback<any[]>), (filter = {}), (options = {});
+      (callback = filter), (filter = {}), (options = {});
     } else {
       if (arguments.length === 3 && typeof options === 'function') {
         (callback = options), (options = {});
@@ -1544,12 +1544,26 @@ export class Collection<TSchema extends Document = Document> {
     );
   }
 
-  /** Initiate an Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order. */
+  /**
+   * Initiate an Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order.
+   *
+   * @throws MongoNotConnectedError
+   * @remarks
+   * **NOTE:** MongoClient must be connected prior to calling this method due to a known limitation in this legacy implemenation.
+   * However, `collection.bulkWrite()` provides an equivalent API that does not require prior connecting.
+   */
   initializeUnorderedBulkOp(options?: BulkWriteOptions): UnorderedBulkOperation {
     return new UnorderedBulkOperation(this as TODO_NODE_3286, resolveOptions(this, options));
   }
 
-  /** Initiate an In order bulk write operation. Operations will be serially executed in the order they are added, creating a new operation for each switch in types. */
+  /**
+   * Initiate an In order bulk write operation. Operations will be serially executed in the order they are added, creating a new operation for each switch in types.
+   *
+   * @throws MongoNotConnectedError
+   * @remarks
+   * **NOTE:** MongoClient must be connected prior to calling this method due to a known limitation in this legacy implemenation.
+   * However, `collection.bulkWrite()` provides an equivalent API that does not require prior connecting.
+   */
   initializeOrderedBulkOp(options?: BulkWriteOptions): OrderedBulkOperation {
     return new OrderedBulkOperation(this as TODO_NODE_3286, resolveOptions(this, options));
   }
@@ -1667,7 +1681,7 @@ export class Collection<TSchema extends Document = Document> {
     callback?: Callback<number>
   ): Promise<number> | void {
     if (typeof filter === 'function') {
-      (callback = filter as Callback<number>), (filter = {}), (options = {});
+      (callback = filter), (filter = {}), (options = {});
     } else {
       if (typeof options === 'function') (callback = options), (options = {});
     }

package/src/cursor/abstract_cursor.ts

@@ -14,6 +14,7 @@ import type { MongoClient } from '../mongo_client';
 import { TODO_NODE_3286, TypedEventEmitter } from '../mongo_types';
 import { executeOperation, ExecutionResult } from '../operations/execute_operation';
 import { GetMoreOperation } from '../operations/get_more';
+import { KillCursorsOperation } from '../operations/kill_cursors';
 import { ReadConcern, ReadConcernLike } from '../read_concern';
 import { ReadPreference, ReadPreferenceLike } from '../read_preference';
 import type { Server } from '../sdam/server';
@@ -66,7 +67,7 @@ export interface CursorCloseOptions {
 /** @public */
 export interface CursorStreamOptions {
   /** A transformation method applied to each document emitted by the stream */
-  transform?(doc: Document): Document;
+  transform?(this: void, doc: Document): Document;
 }
 
 /** @public */
@@ -118,7 +119,7 @@ export abstract class AbstractCursor<
   /** @internal */
   [kId]?: Long;
   /** @internal */
-  [kSession]?: ClientSession;
+  [kSession]: ClientSession;
   /** @internal */
   [kServer]?: Server;
   /** @internal */
@@ -187,6 +188,8 @@ export abstract class AbstractCursor<
 
     if (options.session instanceof ClientSession) {
       this[kSession] = options.session;
+    } else {
+      this[kSession] = this[kClient].startSession({ owner: this, explicit: false });
     }
   }
 
@@ -217,11 +220,11 @@ export abstract class AbstractCursor<
   }
 
   /** @internal */
-  get session(): ClientSession | undefined {
+  get session(): ClientSession {
     return this[kSession];
   }
 
-  set session(clientSession: ClientSession | undefined) {
+  set session(clientSession: ClientSession) {
     this[kSession] = clientSession;
   }
 
@@ -264,7 +267,7 @@ export abstract class AbstractCursor<
   stream(options?: CursorStreamOptions): Readable & AsyncIterable<TSchema> {
     if (options?.transform) {
       const transform = options.transform;
-      const readable = makeCursorStream(this);
+      const readable = new ReadableCursorStream(this);
 
       return readable.pipe(
         new Transform({
@@ -282,7 +285,7 @@ export abstract class AbstractCursor<
       );
     }
 
-    return makeCursorStream(this);
+    return new ReadableCursorStream(this);
   }
 
   hasNext(): Promise<boolean>;
@@ -592,11 +595,12 @@ export abstract class AbstractCursor<
     const session = this[kSession];
     if (session) {
       // We only want to end this session if we created it, and it hasn't ended yet
-      if (session.explicit === false && !session.hasEnded) {
-        session.endSession();
+      if (session.explicit === false) {
+        if (!session.hasEnded) {
+          session.endSession().catch(() => null);
+        }
+        this[kSession] = this.client.startSession({ owner: this, explicit: false });
       }
-
-      this[kSession] = undefined;
     }
   }
 
@@ -644,22 +648,10 @@ export abstract class AbstractCursor<
    * a significant refactor.
    */
   [kInit](callback: Callback<TSchema | null>): void {
-    if (this[kSession] == null) {
-      if (this[kClient].topology?.shouldCheckForSessionSupport()) {
-        return this[kClient].topology?.selectServer(ReadPreference.primaryPreferred, {}, err => {
-          if (err) return callback(err);
-          return this[kInit](callback);
-        });
-      } else if (this[kClient].topology?.hasSessionSupport()) {
-        this[kSession] = this[kClient].topology?.startSession({ owner: this, explicit: false });
-      }
-    }
-
     this._initialize(this[kSession], (err, state) => {
       if (state) {
         const response = state.response;
         this[kServer] = state.server;
-        this[kSession] = state.session;
 
         if (response.cursor) {
           this[kId] =
@@ -714,7 +706,21 @@ function nextDocument<T>(cursor: AbstractCursor): T | null {
   return null;
 }
 
-function next<T>(cursor: AbstractCursor<T>, blocking: boolean, callback: Callback<T | null>): void {
+/**
+ * @param cursor - the cursor on which to call `next`
+ * @param blocking - a boolean indicating whether or not the cursor should `block` until data
+ *     is available.  Generally, this flag is set to `false` because if the getMore returns no documents,
+ *     the cursor has been exhausted.  In certain scenarios (ChangeStreams, tailable await cursors and
+ *     `tryNext`, for example) blocking is necessary because a getMore returning no documents does
+ *     not indicate the end of the cursor.
+ * @param callback - callback to return the result to the caller
+ * @returns
+ */
+export function next<T>(
+  cursor: AbstractCursor<T>,
+  blocking: boolean,
+  callback: Callback<T | null>
+): void {
   const cursorId = cursor[kId];
   if (cursor.closed) {
     return callback(undefined, null);
@@ -829,11 +835,11 @@ function cleanupCursor(
   }
 
   cursor[kKilled] = true;
-  server.killCursors(
-    cursorNs,
-    [cursorId],
-    { ...pluckBSONSerializeOptions(cursor[kOptions]), session },
-    () => completeCleanup()
+
+  return executeOperation(
+    cursor[kClient],
+    new KillCursorsOperation(cursorId, cursorNs, server, { session }),
+    completeCleanup
   );
 }
 
@@ -844,50 +850,41 @@ export function assertUninitialized(cursor: AbstractCursor): void {
   }
 }
 
-function makeCursorStream(cursor: AbstractCursor) {
-  const readable = new Readable({
-    objectMode: true,
-    autoDestroy: false,
-    highWaterMark: 1
-  });
-
-  let initialized = false;
-  let reading = false;
-  let needToClose = true; // NOTE: we must close the cursor if we never read from it, use `_construct` in future node versions
-
-  readable._read = function () {
-    if (initialized === false) {
-      needToClose = false;
-      initialized = true;
-    }
+class ReadableCursorStream extends Readable {
+  private _cursor: AbstractCursor;
+  private _readInProgress = false;
 
-    if (!reading) {
-      reading = true;
-      readNext();
-    }
-  };
+  constructor(cursor: AbstractCursor) {
+    super({
+      objectMode: true,
+      autoDestroy: false,
+      highWaterMark: 1
+    });
+    this._cursor = cursor;
+  }
 
-  readable._destroy = function (error, cb) {
-    if (needToClose) {
-      cursor.close(err => process.nextTick(cb, err || error));
-    } else {
-      cb(error);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  override _read(size: number): void {
+    if (!this._readInProgress) {
+      this._readInProgress = true;
+      this._readNext();
     }
-  };
+  }
 
-  function readNext() {
-    needToClose = false;
-    next(cursor, true, (err, result) => {
-      needToClose = err ? !cursor.closed : result != null;
+  override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
+    this._cursor.close(err => process.nextTick(callback, err || error));
+  }
 
+  private _readNext() {
+    next(this._cursor, true, (err, result) => {
       if (err) {
         // NOTE: This is questionable, but we have a test backing the behavior. It seems the
         //       desired behavior is that a stream ends cleanly when a user explicitly closes
         //       a client during iteration. Alternatively, we could do the "right" thing and
         //       propagate the error message by removing this special case.
         if (err.message.match(/server is closed/)) {
-          cursor.close();
-          return readable.push(null);
+          this._cursor.close().catch(() => null);
+          return this.push(null);
         }
 
         // NOTE: This is also perhaps questionable. The rationale here is that these errors tend
@@ -896,25 +893,23 @@ function makeCursorStream(cursor: AbstractCursor) {
         //       that changed to happen in cleanup legitimate errors would not destroy the
         //       stream. There are change streams test specifically test these cases.
         if (err.message.match(/interrupted/)) {
-          return readable.push(null);
+          return this.push(null);
         }
 
-        return readable.destroy(err);
+        return this.destroy(err);
       }
 
       if (result == null) {
-        readable.push(null);
-      } else if (readable.destroyed) {
-        cursor.close();
+        this.push(null);
+      } else if (this.destroyed) {
+        this._cursor.close().catch(() => null);
       } else {
-        if (readable.push(result)) {
-          return readNext();
+        if (this.push(result)) {
+          return this._readNext();
         }
 
-        reading = false;
+        this._readInProgress = false;
       }
     });
   }
-
-  return readable;
 }

package/src/cursor/change_stream_cursor.ts

@@ -0,0 +1,194 @@
+import type { Document, Long, Timestamp } from '../bson';
+import {
+  type ChangeStreamDocument,
+  type ChangeStreamEvents,
+  type OperationTime,
+  type ResumeToken,
+  ChangeStream
+} from '../change_stream';
+import { INIT, RESPONSE } from '../constants';
+import type { MongoClient } from '../mongo_client';
+import type { TODO_NODE_3286 } from '../mongo_types';
+import { AggregateOperation } from '../operations/aggregate';
+import type { CollationOptions } from '../operations/command';
+import { type ExecutionResult, executeOperation } from '../operations/execute_operation';
+import type { ClientSession } from '../sessions';
+import { type Callback, type MongoDBNamespace, maxWireVersion } from '../utils';
+import { type AbstractCursorOptions, AbstractCursor } from './abstract_cursor';
+
+/** @internal */
+export interface ChangeStreamCursorOptions extends AbstractCursorOptions {
+  startAtOperationTime?: OperationTime;
+  resumeAfter?: ResumeToken;
+  startAfter?: ResumeToken;
+  maxAwaitTimeMS?: number;
+  collation?: CollationOptions;
+  fullDocument?: string;
+}
+
+/** @internal */
+export type ChangeStreamAggregateRawResult<TChange> = {
+  $clusterTime: { clusterTime: Timestamp };
+  cursor: {
+    postBatchResumeToken: ResumeToken;
+    ns: string;
+    id: number | Long;
+  } & ({ firstBatch: TChange[] } | { nextBatch: TChange[] });
+  ok: 1;
+  operationTime: Timestamp;
+};
+
+/** @internal */
+export class ChangeStreamCursor<
+  TSchema extends Document = Document,
+  TChange extends Document = ChangeStreamDocument<TSchema>
+> extends AbstractCursor<TChange, ChangeStreamEvents> {
+  _resumeToken: ResumeToken;
+  startAtOperationTime?: OperationTime;
+  hasReceived?: boolean;
+  resumeAfter: ResumeToken;
+  startAfter: ResumeToken;
+  options: ChangeStreamCursorOptions;
+
+  postBatchResumeToken?: ResumeToken;
+  pipeline: Document[];
+
+  /**
+   * @internal
+   *
+   * used to determine change stream resumability
+   */
+  maxWireVersion: number | undefined;
+
+  constructor(
+    client: MongoClient,
+    namespace: MongoDBNamespace,
+    pipeline: Document[] = [],
+    options: ChangeStreamCursorOptions = {}
+  ) {
+    super(client, namespace, options);
+
+    this.pipeline = pipeline;
+    this.options = options;
+    this._resumeToken = null;
+    this.startAtOperationTime = options.startAtOperationTime;
+
+    if (options.startAfter) {
+      this.resumeToken = options.startAfter;
+    } else if (options.resumeAfter) {
+      this.resumeToken = options.resumeAfter;
+    }
+  }
+
+  set resumeToken(token: ResumeToken) {
+    this._resumeToken = token;
+    this.emit(ChangeStream.RESUME_TOKEN_CHANGED, token);
+  }
+
+  get resumeToken(): ResumeToken {
+    return this._resumeToken;
+  }
+
+  get resumeOptions(): ChangeStreamCursorOptions {
+    const options: ChangeStreamCursorOptions = {
+      ...this.options
+    };
+
+    for (const key of ['resumeAfter', 'startAfter', 'startAtOperationTime'] as const) {
+      delete options[key];
+    }
+
+    if (this.resumeToken != null) {
+      if (this.options.startAfter && !this.hasReceived) {
+        options.startAfter = this.resumeToken;
+      } else {
+        options.resumeAfter = this.resumeToken;
+      }
+    } else if (this.startAtOperationTime != null && maxWireVersion(this.server) >= 7) {
+      options.startAtOperationTime = this.startAtOperationTime;
+    }
+
+    return options;
+  }
+
+  cacheResumeToken(resumeToken: ResumeToken): void {
+    if (this.bufferedCount() === 0 && this.postBatchResumeToken) {
+      this.resumeToken = this.postBatchResumeToken;
+    } else {
+      this.resumeToken = resumeToken;
+    }
+    this.hasReceived = true;
+  }
+
+  _processBatch(response: ChangeStreamAggregateRawResult<TChange>): void {
+    const cursor = response.cursor;
+    if (cursor.postBatchResumeToken) {
+      this.postBatchResumeToken = response.cursor.postBatchResumeToken;
+
+      const batch =
+        'firstBatch' in response.cursor ? response.cursor.firstBatch : response.cursor.nextBatch;
+      if (batch.length === 0) {
+        this.resumeToken = cursor.postBatchResumeToken;
+      }
+    }
+  }
+
+  clone(): AbstractCursor<TChange> {
+    return new ChangeStreamCursor(this.client, this.namespace, this.pipeline, {
+      ...this.cursorOptions
+    });
+  }
+
+  _initialize(session: ClientSession, callback: Callback<ExecutionResult>): void {
+    const aggregateOperation = new AggregateOperation(this.namespace, this.pipeline, {
+      ...this.cursorOptions,
+      ...this.options,
+      session
+    });
+
+    executeOperation<TODO_NODE_3286, ChangeStreamAggregateRawResult<TChange>>(
+      session.client,
+      aggregateOperation,
+      (err, response) => {
+        if (err || response == null) {
+          return callback(err);
+        }
+
+        const server = aggregateOperation.server;
+        this.maxWireVersion = maxWireVersion(server);
+
+        if (
+          this.startAtOperationTime == null &&
+          this.resumeAfter == null &&
+          this.startAfter == null &&
+          this.maxWireVersion >= 7
+        ) {
+          this.startAtOperationTime = response.operationTime;
+        }
+
+        this._processBatch(response);
+
+        this.emit(INIT, response);
+        this.emit(RESPONSE);
+
+        // TODO: NODE-2882
+        callback(undefined, { server, session, response });
+      }
+    );
+  }
+
+  override _getMore(batchSize: number, callback: Callback): void {
+    super._getMore(batchSize, (err, response) => {
+      if (err) {
+        return callback(err);
+      }
+
+      this.maxWireVersion = maxWireVersion(this.server);
+      this._processBatch(response as TODO_NODE_3286 as ChangeStreamAggregateRawResult<TChange>);
+
+      this.emit(ChangeStream.MORE, response);
+      this.emit(ChangeStream.RESPONSE);
+      callback(err, response);
+    });
+  }
+}