mongodb 4.7.0 → 4.9.0

package/src/operations/kill_cursors.ts

@@ -0,0 +1,53 @@
+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';
+
+/**
+ * https://www.mongodb.com/docs/manual/reference/command/killCursors/
+ * @internal
+ */
+interface KillCursorsCommand {
+  killCursors: string;
+  cursors: Long[];
+  comment?: unknown;
+}
+
+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')
+      );
+    }
+
+    const killCursors = this.ns.collection;
+    if (killCursors == null) {
+      // Cursors should have adopted the namespace returned by MongoDB
+      // which should always defined a collection name (even a pseudo one, ex. db.aggregate())
+      return callback(
+        new MongoRuntimeError('A collection name must be determined before killCursors')
+      );
+    }
+
+    const killCursorsCommand: KillCursorsCommand = {
+      killCursors,
+      cursors: [this.cursorId]
+    };
+
+    server.command(this.ns, killCursorsCommand, { 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/common.ts

@@ -1,3 +1,5 @@
+import { clearTimeout } from 'timers';
+
 import type { Binary, Long, Timestamp } from '../bson';
 import type { ClientSession } from '../sessions';
 import type { Topology } from './topology';

package/src/sdam/monitor.ts

@@ -1,4 +1,4 @@
-import { setTimeout } from 'timers';
+import { clearTimeout, setTimeout } from 'timers';
 
 import { Document, Long } from '../bson';
 import { connect } from '../cmap/connect';
@@ -374,6 +374,7 @@ function makeTopologyVersion(tv: TopologyVersion) {
   return {
     processId: tv.processId,
     // tests mock counter as just number, but in a real situation counter should always be a Long
+    // TODO(NODE-2674): Preserve int64 sent from MongoDB
     counter: Long.isLong(tv.counter) ? tv.counter : Long.fromNumber(tv.counter)
   };
 }

package/src/sdam/server.ts

@@ -1,4 +1,4 @@
-import type { Document, Long } from '../bson';
+import type { Document } from '../bson';
 import { CommandOptions, Connection, DestroyOptions, GetMoreOptions } from '../cmap/connection';
 import {
   ConnectionPool,
@@ -29,6 +29,7 @@ import {
   MongoNetworkError,
   MongoNetworkTimeoutError,
   MongoServerClosedError,
+  MongoServerError,
   MongoUnexpectedServerResponseError,
   needsRetryableWriteLabel
 } from '../error';
@@ -374,88 +375,6 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       callback
     );
   }
-
-  /**
-   * Execute a `getMore` against the server
-   * @internal
-   */
-  getMore(
-    ns: MongoDBNamespace,
-    cursorId: Long,
-    options: GetMoreOptions,
-    callback: Callback<Document>
-  ): void {
-    if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
-      callback(new MongoServerClosedError());
-      return;
-    }
-
-    this.s.operationCount += 1;
-
-    this.s.pool.withConnection(
-      options.session?.pinnedConnection,
-      (err, conn, cb) => {
-        if (err || !conn) {
-          this.s.operationCount -= 1;
-          markServerUnknown(this, err);
-          return cb(err);
-        }
-
-        conn.getMore(
-          ns,
-          cursorId,
-          options,
-          makeOperationHandler(this, conn, {}, options, (error, response) => {
-            this.s.operationCount -= 1;
-            cb(error, response);
-          })
-        );
-      },
-      callback
-    );
-  }
-
-  /**
-   * Execute a `killCursors` command against the server
-   * @internal
-   */
-  killCursors(
-    ns: MongoDBNamespace,
-    cursorIds: Long[],
-    options: CommandOptions,
-    callback?: Callback
-  ): void {
-    if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
-      if (typeof callback === 'function') {
-        callback(new MongoServerClosedError());
-      }
-
-      return;
-    }
-
-    this.s.operationCount += 1;
-    this.s.pool.withConnection(
-      options.session?.pinnedConnection,
-      (err, conn, cb) => {
-        if (err || !conn) {
-          this.s.operationCount -= 1;
-          markServerUnknown(this, err);
-          return cb(err);
-        }
-
-        conn.killCursors(
-          ns,
-          cursorIds,
-          options,
-          makeOperationHandler(this, conn, {}, undefined, (error, response) => {
-            this.s.operationCount -= 1;
-            cb(error, response);
-          })
-        );
-      },
-      callback
-    );
-  }
 }
 
 function calculateRoundTripTime(oldRtt: number, duration: number): number {
@@ -467,7 +386,7 @@ function calculateRoundTripTime(oldRtt: number, duration: number): number {
   return alpha * duration + (1 - alpha) * oldRtt;
 }
 
-function markServerUnknown(server: Server, error?: MongoError) {
+function markServerUnknown(server: Server, error?: MongoServerError) {
   // Load balancer servers can never be marked unknown.
   if (server.loadBalanced) {
     return;
@@ -479,11 +398,7 @@ function markServerUnknown(server: Server, error?: MongoError) {
 
   server.emit(
     Server.DESCRIPTION_RECEIVED,
-    new ServerDescription(server.description.hostAddress, undefined, {
-      error,
-      topologyVersion:
-        error && error.topologyVersion ? error.topologyVersion : server.description.topologyVersion
-    })
+    new ServerDescription(server.description.hostAddress, undefined, { error })
   );
 }
 

package/src/sdam/server_description.ts

@@ -1,6 +1,6 @@
 import { Document, Long, ObjectId } from '../bson';
-import type { MongoError } from '../error';
-import { arrayStrictEqual, errorStrictEqual, HostAddress, now } from '../utils';
+import { MongoRuntimeError, MongoServerError } from '../error';
+import { arrayStrictEqual, compareObjectId, errorStrictEqual, HostAddress, now } from '../utils';
 import type { ClusterTime } from './common';
 import { ServerType } from './common';
 
@@ -31,14 +31,11 @@ export type TagSet = { [key: string]: string };
 /** @internal */
 export interface ServerDescriptionOptions {
   /** An Error used for better reporting debugging */
-  error?: MongoError;
+  error?: MongoServerError;
 
   /** The round trip time to ping this server (in ms) */
   roundTripTime?: number;
 
-  /** The topologyVersion */
-  topologyVersion?: TopologyVersion;
-
   /** If the client is in load balancing mode. */
   loadBalanced?: boolean;
 }
@@ -50,28 +47,25 @@ export interface ServerDescriptionOptions {
  * @public
  */
 export class ServerDescription {
-  private _hostAddress: HostAddress;
   address: string;
   type: ServerType;
   hosts: string[];
   passives: string[];
   arbiters: string[];
   tags: TagSet;
-
-  error?: MongoError;
-  topologyVersion?: TopologyVersion;
+  error: MongoServerError | null;
+  topologyVersion: TopologyVersion | null;
   minWireVersion: number;
   maxWireVersion: number;
   roundTripTime: number;
   lastUpdateTime: number;
   lastWriteDate: number;
-
-  me?: string;
-  primary?: string;
-  setName?: string;
-  setVersion?: number;
-  electionId?: ObjectId;
-  logicalSessionTimeoutMinutes?: number;
+  me: string | null;
+  primary: string | null;
+  setName: string | null;
+  setVersion: number | null;
+  electionId: ObjectId | null;
+  logicalSessionTimeoutMinutes: number | null;
 
   // NOTE: does this belong here? It seems we should gossip the cluster time at the CMAP level
   $clusterTime?: ClusterTime;
@@ -83,14 +77,19 @@ export class ServerDescription {
    * @param address - The address of the server
    * @param hello - An optional hello response for this server
    */
-  constructor(address: HostAddress | string, hello?: Document, options?: ServerDescriptionOptions) {
-    if (typeof address === 'string') {
-      this._hostAddress = new HostAddress(address);
-      this.address = this._hostAddress.toString();
-    } else {
-      this._hostAddress = address;
-      this.address = this._hostAddress.toString();
+  constructor(
+    address: HostAddress | string,
+    hello?: Document,
+    options: ServerDescriptionOptions = {}
+  ) {
+    if (address == null || address === '') {
+      throw new MongoRuntimeError('ServerDescription must be provided with a non-empty address');
     }
+
+    this.address =
+      typeof address === 'string'
+        ? HostAddress.fromString(address).toString(false) // Use HostAddress to normalize
+        : address.toString(false);
     this.type = parseServerType(hello, options);
     this.hosts = hello?.hosts?.map((host: string) => host.toLowerCase()) ?? [];
     this.passives = hello?.passives?.map((host: string) => host.toLowerCase()) ?? [];
@@ -101,49 +100,20 @@ export class ServerDescription {
     this.roundTripTime = options?.roundTripTime ?? -1;
     this.lastUpdateTime = now();
     this.lastWriteDate = hello?.lastWrite?.lastWriteDate ?? 0;
-
-    if (options?.topologyVersion) {
-      this.topologyVersion = options.topologyVersion;
-    } else if (hello?.topologyVersion) {
-      this.topologyVersion = hello.topologyVersion;
-    }
-
-    if (options?.error) {
-      this.error = options.error;
-    }
-
-    if (hello?.primary) {
-      this.primary = hello.primary;
-    }
-
-    if (hello?.me) {
-      this.me = hello.me.toLowerCase();
-    }
-
-    if (hello?.setName) {
-      this.setName = hello.setName;
-    }
-
-    if (hello?.setVersion) {
-      this.setVersion = hello.setVersion;
-    }
-
-    if (hello?.electionId) {
-      this.electionId = hello.electionId;
-    }
-
-    if (hello?.logicalSessionTimeoutMinutes) {
-      this.logicalSessionTimeoutMinutes = hello.logicalSessionTimeoutMinutes;
-    }
-
-    if (hello?.$clusterTime) {
-      this.$clusterTime = hello.$clusterTime;
-    }
+    this.error = options.error ?? null;
+    // TODO(NODE-2674): Preserve int64 sent from MongoDB
+    this.topologyVersion = this.error?.topologyVersion ?? hello?.topologyVersion ?? null;
+    this.setName = hello?.setName ?? null;
+    this.setVersion = hello?.setVersion ?? null;
+    this.electionId = hello?.electionId ?? null;
+    this.logicalSessionTimeoutMinutes = hello?.logicalSessionTimeoutMinutes ?? null;
+    this.primary = hello?.primary ?? null;
+    this.me = hello?.me?.toLowerCase() ?? null;
+    this.$clusterTime = hello?.$clusterTime ?? null;
   }
 
   get hostAddress(): HostAddress {
-    if (this._hostAddress) return this._hostAddress;
-    else return new HostAddress(this.address);
+    return HostAddress.fromString(this.address);
   }
 
   get allHosts(): string[] {
@@ -179,15 +149,17 @@ export class ServerDescription {
    * Determines if another `ServerDescription` is equal to this one per the rules defined
    * in the {@link https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#serverdescription|SDAM spec}
    */
-  equals(other: ServerDescription): boolean {
+  equals(other?: ServerDescription | null): boolean {
+    // Despite using the comparator that would determine a nullish topologyVersion as greater than
+    // for equality we should only always perform direct equality comparison
     const topologyVersionsEqual =
-      this.topologyVersion === other.topologyVersion ||
-      compareTopologyVersion(this.topologyVersion, other.topologyVersion) === 0;
+      this.topologyVersion === other?.topologyVersion ||
+      compareTopologyVersion(this.topologyVersion, other?.topologyVersion) === 0;
 
-    const electionIdsEqual: boolean =
-      this.electionId && other.electionId
-        ? other.electionId && this.electionId.equals(other.electionId)
-        : this.electionId === other.electionId;
+    const electionIdsEqual =
+      this.electionId != null && other?.electionId != null
+        ? compareObjectId(this.electionId, other.electionId) === 0
+        : this.electionId === other?.electionId;
 
     return (
       other != null &&
@@ -254,19 +226,37 @@ function tagsStrictEqual(tags: TagSet, tags2: TagSet): boolean {
 /**
  * Compares two topology versions.
  *
- * @returns A negative number if `lhs` is older than `rhs`; positive if `lhs` is newer than `rhs`; 0 if they are equivalent.
+ * 1. If the response topologyVersion is unset or the ServerDescription's
+ *    topologyVersion is null, the client MUST assume the response is more recent.
+ * 1. If the response's topologyVersion.processId is not equal to the
+ *    ServerDescription's, the client MUST assume the response is more recent.
+ * 1. If the response's topologyVersion.processId is equal to the
+ *    ServerDescription's, the client MUST use the counter field to determine
+ *    which topologyVersion is more recent.
+ *
+ * ```ts
+ * currentTv <   newTv === -1
+ * currentTv === newTv === 0
+ * currentTv >   newTv === 1
+ * ```
  */
-export function compareTopologyVersion(lhs?: TopologyVersion, rhs?: TopologyVersion): number {
-  if (lhs == null || rhs == null) {
+export function compareTopologyVersion(
+  currentTv?: TopologyVersion | null,
+  newTv?: TopologyVersion | null
+): 0 | -1 | 1 {
+  if (currentTv == null || newTv == null) {
     return -1;
   }
 
-  if (lhs.processId.equals(rhs.processId)) {
-    // tests mock counter as just number, but in a real situation counter should always be a Long
-    const lhsCounter = Long.isLong(lhs.counter) ? lhs.counter : Long.fromNumber(lhs.counter);
-    const rhsCounter = Long.isLong(rhs.counter) ? lhs.counter : Long.fromNumber(rhs.counter);
-    return lhsCounter.compare(rhsCounter);
+  if (!currentTv.processId.equals(newTv.processId)) {
+    return -1;
   }
 
-  return -1;
+  // TODO(NODE-2674): Preserve int64 sent from MongoDB
+  const currentCounter = Long.isLong(currentTv.counter)
+    ? currentTv.counter
+    : Long.fromNumber(currentTv.counter);
+  const newCounter = Long.isLong(newTv.counter) ? newTv.counter : Long.fromNumber(newTv.counter);
+
+  return currentCounter.compare(newCounter);
 }

package/src/sdam/srv_polling.ts

@@ -1,5 +1,5 @@
 import * as dns from 'dns';
-import { setTimeout } from 'timers';
+import { clearTimeout, setTimeout } from 'timers';
 
 import { MongoRuntimeError } from '../error';
 import { Logger, LoggerOptions } from '../logger';