mongodb 4.1.1 → 4.2.0

package/src/utils.ts

@@ -28,6 +28,7 @@ import type { CommandOperationOptions, OperationParent } from './operations/comm
 import { ReadPreference } from './read_preference';
 import { URL } from 'url';
 import { MAX_SUPPORTED_WIRE_VERSION } from './cmap/wire_protocol/constants';
+import type { SrvRecord } from 'dns';
 
 /**
  * MongoDB Driver style callback
@@ -41,23 +42,6 @@ export const MAX_JS_INT = Number.MAX_SAFE_INTEGER + 1;
 
 export type AnyOptions = Document;
 
-/**
- * Add a readonly enumerable property.
- * @internal
- */
-export function getSingleProperty(
-  obj: AnyOptions,
-  name: string | number | symbol,
-  value: unknown
-): void {
-  Object.defineProperty(obj, name, {
-    enumerable: true,
-    get() {
-      return value;
-    }
-  });
-}
-
 /**
  * Throws if collectionName is not a valid mongodb collection namespace.
  * @internal
@@ -185,17 +169,6 @@ export function isObject(arg: unknown): arg is object {
   return '[object Object]' === Object.prototype.toString.call(arg);
 }
 
-/** @internal */
-export function decorateCommand(command: Document, options: Document, exclude: string[]): Document {
-  for (const name in options) {
-    if (!exclude.includes(name)) {
-      command[name] = options[name];
-    }
-  }
-
-  return command;
-}
-
 /** @internal */
 export function mergeOptions<T, S>(target: T, source: S): T & S {
   return { ...target, ...source };
@@ -657,11 +630,6 @@ export function databaseNamespace(ns: string): string {
   return ns.split('.')[0];
 }
 
-/** @internal */
-export function collectionNamespace(ns: string): string {
-  return ns.split('.').slice(1).join('.');
-}
-
 /**
  * Synchronously Generate a UUIDv4
  * @internal
@@ -987,7 +955,7 @@ export function makeInterruptibleAsyncInterval(
 ): InterruptibleAsyncInterval {
   let timerId: NodeJS.Timeout | undefined;
   let lastCallTime: number;
-  let lastWakeTime: number;
+  let cannotBeExpedited = false;
   let stopped = false;
 
   options = options ?? {};
@@ -998,10 +966,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"
@@ -1009,8 +975,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;
     }
 
@@ -1018,14 +993,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;
     }
   }
 
@@ -1037,7 +1005,7 @@ export function makeInterruptibleAsyncInterval(
     }
 
     lastCallTime = 0;
-    lastWakeTime = 0;
+    cannotBeExpedited = false;
   }
 
   function reschedule(ms?: number) {
@@ -1050,7 +1018,7 @@ export function makeInterruptibleAsyncInterval(
   }
 
   function executeAndReschedule() {
-    lastWakeTime = 0;
+    cannotBeExpedited = false;
     lastCallTime = clock();
 
     fn(err => {
@@ -1128,8 +1096,9 @@ 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);
+/** 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);
   }
@@ -1352,6 +1321,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
    */
@@ -1368,6 +1345,10 @@ export class HostAddress {
   static fromString(s: string): HostAddress {
     return new HostAddress(s);
   }
+
+  static fromSrvRecord({ name, port }: SrvRecord): HostAddress {
+    return HostAddress.fromString(`${name}:${port}`);
+  }
 }
 
 export const DEFAULT_PK_FACTORY = {
@@ -1430,11 +1411,41 @@ export function supportsRetryableWrites(server: Server): boolean {
   );
 }
 
-export function parsePackageVersion({
-  version
-}: {
-  version: string;
-}): { major: number; minor: number; patch: number } {
+export function parsePackageVersion({ version }: { version: string }): {
+  major: number;
+  minor: number;
+  patch: number;
+} {
   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);
+}