mongodb 4.7.0 → 4.8.0

package/src/operations/indexes.ts

@@ -1,6 +1,5 @@
 import type { Document } from '../bson';
 import type { Collection } from '../collection';
-import { AbstractCursor } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
 import { MongoCompatibilityError, MONGODB_ERROR_CODES, MongoServerError } from '../error';
 import type { OneOrMore } from '../mongo_types';
@@ -15,7 +14,6 @@ import {
   OperationParent
 } from './command';
 import { indexInformation, IndexInformationOptions } from './common_functions';
-import { executeOperation, ExecutionResult } from './execute_operation';
 import { AbstractOperation, Aspect, defineAspects } from './operation';
 
 const VALID_INDEX_OPTIONS = new Set([
@@ -412,41 +410,6 @@ export class ListIndexesOperation extends CommandOperation<Document> {
   }
 }
 
-/** @public */
-export class ListIndexesCursor extends AbstractCursor {
-  parent: Collection;
-  options?: ListIndexesOptions;
-
-  constructor(collection: Collection, options?: ListIndexesOptions) {
-    super(collection.s.db.s.client, collection.s.namespace, options);
-    this.parent = collection;
-    this.options = options;
-  }
-
-  clone(): ListIndexesCursor {
-    return new ListIndexesCursor(this.parent, {
-      ...this.options,
-      ...this.cursorOptions
-    });
-  }
-
-  /** @internal */
-  _initialize(session: ClientSession | undefined, callback: Callback<ExecutionResult>): void {
-    const operation = new ListIndexesOperation(this.parent, {
-      ...this.cursorOptions,
-      ...this.options,
-      session
-    });
-
-    executeOperation(this.parent.s.db.s.client, operation, (err, response) => {
-      if (err || response == null) return callback(err);
-
-      // TODO: NODE-2882
-      callback(undefined, { server: operation.server, session, response });
-    });
-  }
-}
-
 /** @internal */
 export class IndexExistsOperation extends AbstractOperation<boolean> {
   override options: IndexInformationOptions;

package/src/operations/kill_cursors.ts

@@ -0,0 +1,27 @@
+import type { Long } from '../bson';
+import { MongoRuntimeError } from '../error';
+import type { Server } from '../sdam/server';
+import type { ClientSession } from '../sessions';
+import type { Callback, MongoDBNamespace } from '../utils';
+import { AbstractOperation, Aspect, defineAspects, OperationOptions } from './operation';
+
+export class KillCursorsOperation extends AbstractOperation {
+  cursorId: Long;
+  constructor(cursorId: Long, ns: MongoDBNamespace, server: Server, options: OperationOptions) {
+    super(options);
+    this.ns = ns;
+    this.cursorId = cursorId;
+    this.server = server;
+  }
+
+  execute(server: Server, session: ClientSession | undefined, callback: Callback<void>): void {
+    if (server !== this.server) {
+      return callback(
+        new MongoRuntimeError('Killcursor must run on the same server operation began on')
+      );
+    }
+    server.killCursors(this.ns, [this.cursorId], { session }, () => callback());
+  }
+}
+
+defineAspects(KillCursorsOperation, [Aspect.MUST_SELECT_SAME_SERVER]);

package/src/operations/list_collections.ts

@@ -1,11 +1,9 @@
 import type { Binary, Document } from '../bson';
-import { AbstractCursor } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { Callback, maxWireVersion } from '../utils';
 import { CommandOperation, CommandOperationOptions } from './command';
-import { executeOperation, ExecutionResult } from './execute_operation';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -86,47 +84,6 @@ export interface CollectionInfo extends Document {
   idIndex?: Document;
 }
 
-/** @public */
-export class ListCollectionsCursor<
-  T extends Pick<CollectionInfo, 'name' | 'type'> | CollectionInfo =
-    | Pick<CollectionInfo, 'name' | 'type'>
-    | CollectionInfo
-> extends AbstractCursor<T> {
-  parent: Db;
-  filter: Document;
-  options?: ListCollectionsOptions;
-
-  constructor(db: Db, filter: Document, options?: ListCollectionsOptions) {
-    super(db.s.client, db.s.namespace, options);
-    this.parent = db;
-    this.filter = filter;
-    this.options = options;
-  }
-
-  clone(): ListCollectionsCursor<T> {
-    return new ListCollectionsCursor(this.parent, this.filter, {
-      ...this.options,
-      ...this.cursorOptions
-    });
-  }
-
-  /** @internal */
-  _initialize(session: ClientSession | undefined, callback: Callback<ExecutionResult>): void {
-    const operation = new ListCollectionsOperation(this.parent, this.filter, {
-      ...this.cursorOptions,
-      ...this.options,
-      session
-    });
-
-    executeOperation(this.parent.s.client, operation, (err, response) => {
-      if (err || response == null) return callback(err);
-
-      // TODO: NODE-2882
-      callback(undefined, { server: operation.server, session, response });
-    });
-  }
-}
-
 defineAspects(ListCollectionsOperation, [
   Aspect.READ_OPERATION,
   Aspect.RETRYABLE,

package/src/operations/operation.ts

@@ -11,7 +11,7 @@ export const Aspect = {
   EXPLAINABLE: Symbol('EXPLAINABLE'),
   SKIP_COLLATION: Symbol('SKIP_COLLATION'),
   CURSOR_CREATING: Symbol('CURSOR_CREATING'),
-  CURSOR_ITERATING: Symbol('CURSOR_ITERATING')
+  MUST_SELECT_SAME_SERVER: Symbol('MUST_SELECT_SAME_SERVER')
 } as const;
 
 /** @public */
@@ -94,6 +94,10 @@ export abstract class AbstractOperation<TResult = any> {
     return this[kSession];
   }
 
+  clearSession() {
+    this[kSession] = undefined;
+  }
+
   get canRetryRead(): boolean {
     return true;
   }

package/src/read_preference.ts

@@ -163,14 +163,10 @@ export class ReadPreference {
     } else if (!(readPreference instanceof ReadPreference) && typeof readPreference === 'object') {
       const mode = readPreference.mode || readPreference.preference;
       if (mode && typeof mode === 'string') {
-        return new ReadPreference(
-          mode as ReadPreferenceMode,
-          readPreference.tags ?? readPreferenceTags,
-          {
-            maxStalenessSeconds: readPreference.maxStalenessSeconds,
-            hedge: options.hedge
-          }
-        );
+        return new ReadPreference(mode, readPreference.tags ?? readPreferenceTags, {
+          maxStalenessSeconds: readPreference.maxStalenessSeconds,
+          hedge: options.hedge
+        });
       }
     }
 
@@ -193,7 +189,7 @@ export class ReadPreference {
     } else if (r && !(r instanceof ReadPreference) && typeof r === 'object') {
       const mode = r.mode || r.preference;
       if (mode && typeof mode === 'string') {
-        options.readPreference = new ReadPreference(mode as ReadPreferenceMode, r.tags, {
+        options.readPreference = new ReadPreference(mode, r.tags, {
           maxStalenessSeconds: r.maxStalenessSeconds
         });
       }

package/src/sdam/topology.ts

@@ -1,5 +1,6 @@
 import Denque = require('denque');
 import { setTimeout } from 'timers';
+import { promisify } from 'util';
 
 import type { BSONSerializeOptions, Document } from '../bson';
 import { deserialize, serialize } from '../bson';
@@ -29,20 +30,14 @@ import {
   MongoServerSelectionError,
   MongoTopologyClosedError
 } from '../error';
-import type { MongoClient, MongoOptions, ServerApi } from '../mongo_client';
+import type { MongoClient, ServerApi } from '../mongo_client';
 import { TypedEventEmitter } from '../mongo_types';
 import { ReadPreference, ReadPreferenceLike } from '../read_preference';
-import {
-  ClientSession,
-  ClientSessionOptions,
-  ServerSessionId,
-  ServerSessionPool
-} from '../sessions';
+import type { ClientSession } from '../sessions';
 import type { Transaction } from '../transactions';
 import {
   Callback,
   ClientMetadata,
-  eachAsync,
   emitWarning,
   EventEmitterWithState,
   HostAddress,
@@ -120,10 +115,6 @@ export interface TopologyPrivate {
   minHeartbeatFrequencyMS: number;
   /** A map of server instances to normalized addresses */
   servers: Map<string, Server>;
-  /** Server Session Pool */
-  sessionPool: ServerSessionPool;
-  /** Active client sessions */
-  sessions: Set<ClientSession>;
   credentials?: MongoCredentials;
   clusterTime?: ClusterTime;
   /** timers created for the initial connect to a server */
@@ -316,10 +307,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       minHeartbeatFrequencyMS: options.minHeartbeatFrequencyMS,
       // a map of server instances to normalized addresses
       servers: new Map(),
-      // Server Session Pool
-      sessionPool: new ServerSessionPool(this),
-      // Active client sessions
-      sessions: new Set(),
       credentials: options?.credentials,
       clusterTime: undefined,
 
@@ -443,13 +430,13 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       }
     }
 
+    const exitWithError = (error: Error) =>
+      callback ? callback(error) : this.emit(Topology.ERROR, error);
+
     const readPreference = options.readPreference ?? ReadPreference.primary;
     this.selectServer(readPreferenceServerSelector(readPreference), options, (err, server) => {
       if (err) {
-        this.close();
-
-        typeof callback === 'function' ? callback(err) : this.emit(Topology.ERROR, err);
-        return;
+        return this.close({ force: false }, () => exitWithError(err));
       }
 
       // TODO: NODE-2471
@@ -457,15 +444,14 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       if (!skipPingOnConnect && server && this.s.credentials) {
         server.command(ns('admin.$cmd'), { ping: 1 }, {}, err => {
           if (err) {
-            typeof callback === 'function' ? callback(err) : this.emit(Topology.ERROR, err);
-            return;
+            return exitWithError(err);
           }
 
           stateTransition(this, STATE_CONNECTED);
           this.emit(Topology.OPEN, this);
           this.emit(Topology.CONNECT, this);
 
-          if (typeof callback === 'function') callback(undefined, this);
+          callback?.(undefined, this);
         });
 
         return;
@@ -475,7 +461,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       this.emit(Topology.OPEN, this);
       this.emit(Topology.CONNECT, this);
 
-      if (typeof callback === 'function') callback(undefined, this);
+      callback?.(undefined, this);
     });
   }
 
@@ -489,52 +475,38 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     if (typeof options === 'boolean') {
       options = { force: options };
     }
-
     options = options ?? {};
-    if (this.s.state === STATE_CLOSED || this.s.state === STATE_CLOSING) {
-      if (typeof callback === 'function') {
-        callback();
-      }
 
-      return;
+    if (this.s.state === STATE_CLOSED || this.s.state === STATE_CLOSING) {
+      return callback?.();
     }
 
-    stateTransition(this, STATE_CLOSING);
+    const destroyedServers = Array.from(this.s.servers.values(), server => {
+      return promisify(destroyServer)(server, this, options);
+    });
 
-    drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
-    drainTimerQueue(this.s.connectionTimers);
+    Promise.all(destroyedServers)
+      .then(() => {
+        this.s.servers.clear();
 
-    if (this.s.srvPoller) {
-      this.s.srvPoller.stop();
-      this.s.srvPoller.removeListener(SrvPoller.SRV_RECORD_DISCOVERY, this.s.detectSrvRecords);
-    }
+        stateTransition(this, STATE_CLOSING);
 
-    this.removeListener(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
-
-    eachAsync(
-      Array.from(this.s.sessions.values()),
-      (session, cb) => session.endSession(cb),
-      () => {
-        this.s.sessionPool.endAllPooledSessions(() => {
-          eachAsync(
-            Array.from(this.s.servers.values()),
-            (server, cb) => destroyServer(server, this, options, cb),
-            err => {
-              this.s.servers.clear();
-
-              // emit an event for close
-              this.emit(Topology.TOPOLOGY_CLOSED, new TopologyClosedEvent(this.s.id));
-
-              stateTransition(this, STATE_CLOSED);
-
-              if (typeof callback === 'function') {
-                callback(err);
-              }
-            }
-          );
-        });
-      }
-    );
+        drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
+        drainTimerQueue(this.s.connectionTimers);
+
+        if (this.s.srvPoller) {
+          this.s.srvPoller.stop();
+          this.s.srvPoller.removeListener(SrvPoller.SRV_RECORD_DISCOVERY, this.s.detectSrvRecords);
+        }
+
+        this.removeListener(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
+
+        stateTransition(this, STATE_CLOSED);
+
+        // emit an event for close
+        this.emit(Topology.TOPOLOGY_CLOSED, new TopologyClosedEvent(this.s.id));
+      })
+      .finally(() => callback?.());
   }
 
   /**
@@ -628,44 +600,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     return this.loadBalanced || this.description.logicalSessionTimeoutMinutes != null;
   }
 
-  /** Start a logical session */
-  startSession(options: ClientSessionOptions, clientOptions?: MongoOptions): ClientSession {
-    const session = new ClientSession(this.client, this.s.sessionPool, options, clientOptions);
-    session.once('ended', () => {
-      this.s.sessions.delete(session);
-    });
-
-    this.s.sessions.add(session);
-    return session;
-  }
-
-  /** Send endSessions command(s) with the given session ids */
-  endSessions(sessions: ServerSessionId[], callback?: Callback<Document>): void {
-    if (!Array.isArray(sessions)) {
-      sessions = [sessions];
-    }
-
-    this.selectServer(
-      readPreferenceServerSelector(ReadPreference.primaryPreferred),
-      {},
-      (err, server) => {
-        if (err || !server) {
-          if (typeof callback === 'function') callback(err);
-          return;
-        }
-
-        server.command(
-          ns('admin.$cmd'),
-          { endSessions: sessions },
-          { noResponse: true },
-          (err, result) => {
-            if (typeof callback === 'function') callback(err, result);
-          }
-        );
-      }
-    );
-  }
-
   /**
    * Update the internal TopologyDescription with a ServerDescription
    *

package/src/sessions.ts

@@ -27,7 +27,6 @@ import { PromiseProvider } from './promise_provider';
 import { ReadConcernLevel } from './read_concern';
 import { ReadPreference } from './read_preference';
 import { _advanceClusterTime, ClusterTime, TopologyType } from './sdam/common';
-import type { Topology } from './sdam/topology';
 import { isTransactionCommand, Transaction, TransactionOptions, TxnState } from './transactions';
 import {
   calculateDurationInMs,
@@ -269,9 +268,10 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
         if (serverSession != null) {
           // release the server session back to the pool
           this.sessionPool.release(serverSession);
-          // Make sure a new serverSession never makes it on to the ClientSession
+          // Make sure a new serverSession never makes it onto this ClientSession
           Object.defineProperty(this, kServerSession, {
-            value: ServerSession.clone(serverSession)
+            value: ServerSession.clone(serverSession),
+            writable: false
           });
         }
 
@@ -616,7 +616,7 @@ function attemptTransaction<TSchema>(
   }
 
   if (!isPromiseLike(promise)) {
-    session.abortTransaction();
+    session.abortTransaction().catch(() => null);
     throw new MongoInvalidArgumentError(
       'Function provided to `withTransaction` must return a Promise'
     );
@@ -878,39 +878,18 @@ export class ServerSession {
  * @internal
  */
 export class ServerSessionPool {
-  topology: Topology;
+  client: MongoClient;
   sessions: ServerSession[];
 
-  constructor(topology: Topology) {
-    if (topology == null) {
-      throw new MongoRuntimeError('ServerSessionPool requires a topology');
+  constructor(client: MongoClient) {
+    if (client == null) {
+      throw new MongoRuntimeError('ServerSessionPool requires a MongoClient');
     }
 
-    this.topology = topology;
+    this.client = client;
     this.sessions = [];
   }
 
-  /** Ends all sessions in the session pool */
-  endAllPooledSessions(callback?: Callback<void>): void {
-    if (this.sessions.length) {
-      this.topology.endSessions(
-        this.sessions.map((session: ServerSession) => session.id),
-        () => {
-          this.sessions = [];
-          if (typeof callback === 'function') {
-            callback();
-          }
-        }
-      );
-
-      return;
-    }
-
-    if (typeof callback === 'function') {
-      callback();
-    }
-  }
-
   /**
    * Acquire a Server Session from the pool.
    * Iterates through each session in the pool, removing any stale sessions
@@ -918,16 +897,29 @@ export class ServerSessionPool {
    * pool and returned. If no non-stale session is found, a new ServerSession is created.
    */
   acquire(): ServerSession {
-    const sessionTimeoutMinutes = this.topology.logicalSessionTimeoutMinutes || 10;
+    const sessionTimeoutMinutes = this.client.topology?.logicalSessionTimeoutMinutes ?? 10;
 
-    while (this.sessions.length) {
-      const session = this.sessions.shift();
-      if (session && (this.topology.loadBalanced || !session.hasTimedOut(sessionTimeoutMinutes))) {
-        return session;
+    let session: ServerSession | null = null;
+
+    // Try to obtain from session pool
+    while (this.sessions.length > 0) {
+      const potentialSession = this.sessions.shift();
+      if (
+        potentialSession != null &&
+        (!!this.client.topology?.loadBalanced ||
+          !potentialSession.hasTimedOut(sessionTimeoutMinutes))
+      ) {
+        session = potentialSession;
+        break;
       }
     }
 
-    return new ServerSession();
+    // If nothing valid came from the pool make a new one
+    if (session == null) {
+      session = new ServerSession();
+    }
+
+    return session;
   }
 
   /**
@@ -938,9 +930,9 @@ export class ServerSessionPool {
    * @param session - The session to release to the pool
    */
   release(session: ServerSession): void {
-    const sessionTimeoutMinutes = this.topology.logicalSessionTimeoutMinutes;
+    const sessionTimeoutMinutes = this.client.topology?.logicalSessionTimeoutMinutes ?? 10;
 
-    if (this.topology.loadBalanced && !sessionTimeoutMinutes) {
+    if (this.client.topology?.loadBalanced && !sessionTimeoutMinutes) {
       this.sessions.unshift(session);
     }
 

package/src/utils.ts

@@ -161,14 +161,15 @@ export function parseIndexOptions(indexSpec: IndexSpecification): IndexOptions {
   };
 }
 
+const TO_STRING = (object: unknown) => Object.prototype.toString.call(object);
 /**
  * Checks if arg is an Object:
  * - **NOTE**: the check is based on the `[Symbol.toStringTag]() === 'Object'`
  * @internal
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
+
 export function isObject(arg: unknown): arg is object {
-  return '[object Object]' === Object.prototype.toString.call(arg);
+  return '[object Object]' === TO_STRING(arg);
 }
 
 /** @internal */
@@ -380,7 +381,7 @@ export interface DeprecateOptionsConfig {
   /** index of options object in function arguments array */
   optionsIndex: number;
   /** optional custom message handler to generate warnings */
-  msgHandler?(name: string, option: string): string;
+  msgHandler?(this: void, name: string, option: string): string;
 }
 
 /**
@@ -1024,6 +1025,9 @@ export function setDifference<T>(setA: Iterable<T>, setB: Iterable<T>): Set<T> {
   return difference;
 }
 
+const HAS_OWN = (object: unknown, prop: string) =>
+  Object.prototype.hasOwnProperty.call(object, prop);
+
 export function isRecord<T extends readonly string[]>(
   value: unknown,
   requiredKeys: T
@@ -1033,9 +1037,6 @@ export function isRecord(
   value: unknown,
   requiredKeys: string[] | undefined = undefined
 ): value is Record<string, any> {
-  const toString = Object.prototype.toString;
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  const isObject = (v: unknown) => toString.call(v) === '[object Object]';
   if (!isObject(value)) {
     return false;
   }
@@ -1047,7 +1048,7 @@ export function isRecord(
     }
 
     // Check to see if some method exists from the Object exists
-    if (!hasOwnProperty.call(ctor.prototype, 'isPrototypeOf')) {
+    if (!HAS_OWN(ctor.prototype, 'isPrototypeOf')) {
       return false;
     }
   }
@@ -1261,7 +1262,7 @@ export class HostAddress {
     return `${this.socketPath}`;
   }
 
-  static fromString(s: string): HostAddress {
+  static fromString(this: void, s: string): HostAddress {
     return new HostAddress(s);
   }
 
@@ -1406,3 +1407,26 @@ export function commandSupportsReadConcern(command: Document, options?: Document
 
   return false;
 }
+
+/**
+ * A utility function to get the instance of mongodb-client-encryption, if it exists.
+ *
+ * @throws MongoMissingDependencyError if mongodb-client-encryption isn't installed.
+ * @returns
+ */
+export function getMongoDBClientEncryption() {
+  let mongodbClientEncryption;
+
+  // NOTE(NODE-4254): This is to get around the circular dependency between
+  // mongodb-client-encryption and the driver in the test scenarios.
+  if (
+    typeof process.env.MONGODB_CLIENT_ENCRYPTION_OVERRIDE === 'string' &&
+    process.env.MONGODB_CLIENT_ENCRYPTION_OVERRIDE.length > 0
+  ) {
+    mongodbClientEncryption = require(process.env.MONGODB_CLIENT_ENCRYPTION_OVERRIDE);
+  } else {
+    mongodbClientEncryption = require('mongodb-client-encryption');
+  }
+
+  return mongodbClientEncryption;
+}