mongodb 4.1.4 → 4.3.0

package/src/utils.ts

@@ -1,33 +1,36 @@
-import * as os from 'os';
 import * as crypto from 'crypto';
-import { PromiseProvider } from './promise_provider';
+import type { SrvRecord } from 'dns';
+import * as os from 'os';
+import { URL } from 'url';
+
+import { Document, ObjectId, resolveBSONOptions } from './bson';
+import type { Connection } from './cmap/connection';
+import { MAX_SUPPORTED_WIRE_VERSION } from './cmap/wire_protocol/constants';
+import type { Collection } from './collection';
+import { LEGACY_HELLO_COMMAND } from './constants';
+import type { Db } from './db';
 import {
   AnyError,
-  MongoParseError,
-  MongoRuntimeError,
   MongoCompatibilityError,
-  MongoNotConnectedError,
+  MongoExpiredSessionError,
   MongoInvalidArgumentError,
-  MongoExpiredSessionError
+  MongoNotConnectedError,
+  MongoParseError,
+  MongoRuntimeError
 } from './error';
-import { WriteConcern, WriteConcernOptions, W } from './write_concern';
-import type { Server } from './sdam/server';
-import type { Topology } from './sdam/topology';
-import { ServerType } from './sdam/common';
-import type { Db } from './db';
-import type { Collection } from './collection';
-import type { OperationOptions, Hint } from './operations/operation';
-import type { ClientSession } from './sessions';
-import { ReadConcern } from './read_concern';
-import type { Connection } from './cmap/connection';
-import { Document, ObjectId, resolveBSONOptions } from './bson';
-import type { IndexSpecification, IndexDirection } from './operations/indexes';
 import type { Explain } from './explain';
 import type { MongoClient } from './mongo_client';
 import type { CommandOperationOptions, OperationParent } from './operations/command';
+import type { IndexDirection, IndexSpecification } from './operations/indexes';
+import type { Hint, OperationOptions } from './operations/operation';
+import { PromiseProvider } from './promise_provider';
+import { ReadConcern } from './read_concern';
 import { ReadPreference } from './read_preference';
-import { URL } from 'url';
-import { MAX_SUPPORTED_WIRE_VERSION } from './cmap/wire_protocol/constants';
+import { ServerType } from './sdam/common';
+import type { Server } from './sdam/server';
+import type { Topology } from './sdam/topology';
+import type { ClientSession } from './sessions';
+import { W, WriteConcern, WriteConcernOptions } from './write_concern';
 
 /**
  * MongoDB Driver style callback
@@ -954,7 +957,7 @@ export function makeInterruptibleAsyncInterval(
 ): InterruptibleAsyncInterval {
   let timerId: NodeJS.Timeout | undefined;
   let lastCallTime: number;
-  let lastWakeTime: number;
+  let cannotBeExpedited = false;
   let stopped = false;
 
   options = options ?? {};
@@ -965,10 +968,8 @@ export function makeInterruptibleAsyncInterval(
 
   function wake() {
     const currentTime = clock();
-    const timeSinceLastWake = currentTime - lastWakeTime;
-    const timeSinceLastCall = currentTime - lastCallTime;
-    const timeUntilNextCall = interval - timeSinceLastCall;
-    lastWakeTime = currentTime;
+    const nextScheduledCallTime = lastCallTime + interval;
+    const timeUntilNextCall = nextScheduledCallTime - currentTime;
 
     // For the streaming protocol: there is nothing obviously stopping this
     // interval from being woken up again while we are waiting "infinitely"
@@ -976,8 +977,17 @@ export function makeInterruptibleAsyncInterval(
     // never completes, the `timeUntilNextCall` will continue to grow
     // negatively unbounded, so it will never trigger a reschedule here.
 
+    // This is possible in virtualized environments like AWS Lambda where our
+    // clock is unreliable. In these cases the timer is "running" but never
+    // actually completes, so we want to execute immediately and then attempt
+    // to reschedule.
+    if (timeUntilNextCall < 0) {
+      executeAndReschedule();
+      return;
+    }
+
     // debounce multiple calls to wake within the `minInterval`
-    if (timeSinceLastWake < minInterval) {
+    if (cannotBeExpedited) {
       return;
     }
 
@@ -985,14 +995,7 @@ export function makeInterruptibleAsyncInterval(
     // faster than the `minInterval`
     if (timeUntilNextCall > minInterval) {
       reschedule(minInterval);
-    }
-
-    // This is possible in virtualized environments like AWS Lambda where our
-    // clock is unreliable. In these cases the timer is "running" but never
-    // actually completes, so we want to execute immediately and then attempt
-    // to reschedule.
-    if (timeUntilNextCall < 0) {
-      executeAndReschedule();
+      cannotBeExpedited = true;
     }
   }
 
@@ -1004,7 +1007,7 @@ export function makeInterruptibleAsyncInterval(
     }
 
     lastCallTime = 0;
-    lastWakeTime = 0;
+    cannotBeExpedited = false;
   }
 
   function reschedule(ms?: number) {
@@ -1017,7 +1020,7 @@ export function makeInterruptibleAsyncInterval(
   }
 
   function executeAndReschedule() {
-    lastWakeTime = 0;
+    cannotBeExpedited = false;
     lastCallTime = clock();
 
     fn(err => {
@@ -1095,8 +1098,17 @@ export function isSuperset(set: Set<any> | any[], subset: Set<any> | any[]): boo
   return true;
 }
 
-export function setDifference(setA: Iterable<any>, setB: Iterable<any>): Set<any> {
-  const difference = new Set(setA);
+/**
+ * Checks if the document is a Hello request
+ * @internal
+ */
+export function isHello(doc: Document): boolean {
+  return doc[LEGACY_HELLO_COMMAND] || doc.hello ? true : false;
+}
+
+/** Returns the items that are uniquely in setA */
+export function setDifference<T>(setA: Iterable<T>, setB: Iterable<T>): Set<T> {
+  const difference = new Set<T>(setA);
   for (const elem of setB) {
     difference.delete(elem);
   }
@@ -1146,11 +1158,11 @@ export function isRecord(
  * but instead something that is good enough for the purposes of
  * command monitoring.
  */
-export function deepCopy<T extends any>(value: T): T {
+export function deepCopy<T>(value: T): T {
   if (value == null) {
     return value;
   } else if (Array.isArray(value)) {
-    return value.map(item => deepCopy(item)) as T;
+    return value.map(item => deepCopy(item)) as unknown as T;
   } else if (isRecord(value)) {
     const res = {} as any;
     for (const key in value) {
@@ -1165,11 +1177,11 @@ export function deepCopy<T extends any>(value: T): T {
       case 'date':
         return new ctor(Number(value));
       case 'map':
-        return new Map(value as any) as T;
+        return new Map(value as any) as unknown as T;
       case 'set':
-        return new Set(value as any) as T;
+        return new Set(value as any) as unknown as T;
       case 'buffer':
-        return Buffer.from(value as Buffer) as T;
+        return Buffer.from(value as Buffer) as unknown as T;
     }
   }
 
@@ -1319,6 +1331,14 @@ export class HostAddress {
     Object.freeze(this);
   }
 
+  [Symbol.for('nodejs.util.inspect.custom')](): string {
+    return this.inspect();
+  }
+
+  inspect(): string {
+    return `new HostAddress('${this.toString(true)}')`;
+  }
+
   /**
    * @param ipv6Brackets - optionally request ipv6 bracket notation required for connection strings
    */
@@ -1335,6 +1355,17 @@ export class HostAddress {
   static fromString(s: string): HostAddress {
     return new HostAddress(s);
   }
+
+  static fromHostPort(host: string, port: number): HostAddress {
+    if (host.includes(':')) {
+      host = `[${host}]`; // IPv6 address
+    }
+    return HostAddress.fromString(`${host}:${port}`);
+  }
+
+  static fromSrvRecord({ name, port }: SrvRecord): HostAddress {
+    return HostAddress.fromHostPort(name, port);
+  }
 }
 
 export const DEFAULT_PK_FACTORY = {
@@ -1405,3 +1436,52 @@ export function parsePackageVersion({ version }: { version: string }): {
   const [major, minor, patch] = version.split('.').map((n: string) => Number.parseInt(n, 10));
   return { major, minor, patch };
 }
+
+/**
+ * Fisher–Yates Shuffle
+ *
+ * Reference: https://bost.ocks.org/mike/shuffle/
+ * @param sequence - items to be shuffled
+ * @param limit - Defaults to `0`. If nonzero shuffle will slice the randomized array e.g, `.slice(0, limit)` otherwise will return the entire randomized array.
+ */
+export function shuffle<T>(sequence: Iterable<T>, limit = 0): Array<T> {
+  const items = Array.from(sequence); // shallow copy in order to never shuffle the input
+
+  if (limit > items.length) {
+    throw new MongoRuntimeError('Limit must be less than the number of items');
+  }
+
+  let remainingItemsToShuffle = items.length;
+  const lowerBound = limit % items.length === 0 ? 1 : items.length - limit;
+  while (remainingItemsToShuffle > lowerBound) {
+    // Pick a remaining element
+    const randomIndex = Math.floor(Math.random() * remainingItemsToShuffle);
+    remainingItemsToShuffle -= 1;
+
+    // And swap it with the current element
+    const swapHold = items[remainingItemsToShuffle];
+    items[remainingItemsToShuffle] = items[randomIndex];
+    items[randomIndex] = swapHold;
+  }
+
+  return limit % items.length === 0 ? items : items.slice(lowerBound);
+}
+
+// TODO: this should be codified in command construction
+// @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#read-concern
+export function commandSupportsReadConcern(command: Document, options?: Document): boolean {
+  if (command.aggregate || command.count || command.distinct || command.find || command.geoNear) {
+    return true;
+  }
+
+  if (
+    command.mapReduce &&
+    options &&
+    options.out &&
+    (options.out.inline === 1 || options.out === 'inline')
+  ) {
+    return true;
+  }
+
+  return false;
+}

package/lib/cmap/auth/defaultAuthProviders.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUTH_PROVIDERS = exports.AuthMechanism = void 0;
-const mongocr_1 = require("./mongocr");
-const x509_1 = require("./x509");
-const plain_1 = require("./plain");
-const gssapi_1 = require("./gssapi");
-const scram_1 = require("./scram");
-const mongodb_aws_1 = require("./mongodb_aws");
-/** @public */
-exports.AuthMechanism = Object.freeze({
-    MONGODB_AWS: 'MONGODB-AWS',
-    MONGODB_CR: 'MONGODB-CR',
-    MONGODB_DEFAULT: 'DEFAULT',
-    MONGODB_GSSAPI: 'GSSAPI',
-    MONGODB_PLAIN: 'PLAIN',
-    MONGODB_SCRAM_SHA1: 'SCRAM-SHA-1',
-    MONGODB_SCRAM_SHA256: 'SCRAM-SHA-256',
-    MONGODB_X509: 'MONGODB-X509'
-});
-exports.AUTH_PROVIDERS = new Map([
-    [exports.AuthMechanism.MONGODB_AWS, new mongodb_aws_1.MongoDBAWS()],
-    [exports.AuthMechanism.MONGODB_CR, new mongocr_1.MongoCR()],
-    [exports.AuthMechanism.MONGODB_GSSAPI, new gssapi_1.GSSAPI()],
-    [exports.AuthMechanism.MONGODB_PLAIN, new plain_1.Plain()],
-    [exports.AuthMechanism.MONGODB_SCRAM_SHA1, new scram_1.ScramSHA1()],
-    [exports.AuthMechanism.MONGODB_SCRAM_SHA256, new scram_1.ScramSHA256()],
-    [exports.AuthMechanism.MONGODB_X509, new x509_1.X509()]
-]);
-//# sourceMappingURL=defaultAuthProviders.js.map

package/lib/cmap/auth/defaultAuthProviders.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultAuthProviders.js","sourceRoot":"","sources":["../../../src/cmap/auth/defaultAuthProviders.ts"],"names":[],"mappings":";;;AAAA,uCAAoC;AACpC,iCAA8B;AAC9B,mCAAgC;AAChC,qCAAkC;AAClC,mCAAiD;AACjD,+CAA2C;AAG3C,cAAc;AACD,QAAA,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC;IACzC,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,YAAY;IACxB,eAAe,EAAE,SAAS;IAC1B,cAAc,EAAE,QAAQ;IACxB,aAAa,EAAE,OAAO;IACtB,kBAAkB,EAAE,aAAa;IACjC,oBAAoB,EAAE,eAAe;IACrC,YAAY,EAAE,cAAc;CACpB,CAAC,CAAC;AAKC,QAAA,cAAc,GAAG,IAAI,GAAG,CAAuC;IAC1E,CAAC,qBAAa,CAAC,WAAW,EAAE,IAAI,wBAAU,EAAE,CAAC;IAC7C,CAAC,qBAAa,CAAC,UAAU,EAAE,IAAI,iBAAO,EAAE,CAAC;IACzC,CAAC,qBAAa,CAAC,cAAc,EAAE,IAAI,eAAM,EAAE,CAAC;IAC5C,CAAC,qBAAa,CAAC,aAAa,EAAE,IAAI,aAAK,EAAE,CAAC;IAC1C,CAAC,qBAAa,CAAC,kBAAkB,EAAE,IAAI,iBAAS,EAAE,CAAC;IACnD,CAAC,qBAAa,CAAC,oBAAoB,EAAE,IAAI,mBAAW,EAAE,CAAC;IACvD,CAAC,qBAAa,CAAC,YAAY,EAAE,IAAI,WAAI,EAAE,CAAC;CACzC,CAAC,CAAC"}

package/src/cmap/auth/defaultAuthProviders.ts

@@ -1,32 +0,0 @@
-import { MongoCR } from './mongocr';
-import { X509 } from './x509';
-import { Plain } from './plain';
-import { GSSAPI } from './gssapi';
-import { ScramSHA1, ScramSHA256 } from './scram';
-import { MongoDBAWS } from './mongodb_aws';
-import type { AuthProvider } from './auth_provider';
-
-/** @public */
-export const AuthMechanism = Object.freeze({
-  MONGODB_AWS: 'MONGODB-AWS',
-  MONGODB_CR: 'MONGODB-CR',
-  MONGODB_DEFAULT: 'DEFAULT',
-  MONGODB_GSSAPI: 'GSSAPI',
-  MONGODB_PLAIN: 'PLAIN',
-  MONGODB_SCRAM_SHA1: 'SCRAM-SHA-1',
-  MONGODB_SCRAM_SHA256: 'SCRAM-SHA-256',
-  MONGODB_X509: 'MONGODB-X509'
-} as const);
-
-/** @public */
-export type AuthMechanism = typeof AuthMechanism[keyof typeof AuthMechanism];
-
-export const AUTH_PROVIDERS = new Map<AuthMechanism | string, AuthProvider>([
-  [AuthMechanism.MONGODB_AWS, new MongoDBAWS()],
-  [AuthMechanism.MONGODB_CR, new MongoCR()],
-  [AuthMechanism.MONGODB_GSSAPI, new GSSAPI()],
-  [AuthMechanism.MONGODB_PLAIN, new Plain()],
-  [AuthMechanism.MONGODB_SCRAM_SHA1, new ScramSHA1()],
-  [AuthMechanism.MONGODB_SCRAM_SHA256, new ScramSHA256()],
-  [AuthMechanism.MONGODB_X509, new X509()]
-]);