@depup/mongodb 7.1.0-depup.0

package/src/sdam/server_description.ts

@@ -0,0 +1,297 @@
+import { type Document, Long, type ObjectId } from '../bson';
+import { type MongoError, MongoRuntimeError } from '../error';
+import {
+  arrayStrictEqual,
+  compareObjectId,
+  errorStrictEqual,
+  HostAddress,
+  processTimeMS
+} from '../utils';
+import { type ClusterTime, ServerType } from './common';
+
+const WRITABLE_SERVER_TYPES = new Set<ServerType>([
+  ServerType.RSPrimary,
+  ServerType.Standalone,
+  ServerType.Mongos,
+  ServerType.LoadBalancer
+]);
+
+const DATA_BEARING_SERVER_TYPES = new Set<ServerType>([
+  ServerType.RSPrimary,
+  ServerType.RSSecondary,
+  ServerType.Mongos,
+  ServerType.Standalone,
+  ServerType.LoadBalancer
+]);
+
+/** @public */
+export interface TopologyVersion {
+  processId: ObjectId;
+  counter: Long;
+}
+
+/** @public */
+export type TagSet = { [key: string]: string };
+
+/** @internal */
+export interface ServerDescriptionOptions {
+  /** An Error used for better reporting debugging */
+  error?: MongoError;
+
+  /** The average round trip time to ping this server (in ms) */
+  roundTripTime?: number;
+  /** The minimum round trip time to ping this server over the past 10 samples(in ms) */
+  minRoundTripTime?: number;
+
+  /** If the client is in load balancing mode. */
+  loadBalanced?: boolean;
+}
+
+/**
+ * The client's view of a single server, based on the most recent hello outcome.
+ *
+ * Internal type, not meant to be directly instantiated
+ * @public
+ */
+export class ServerDescription {
+  address: string;
+  type: ServerType;
+  hosts: string[];
+  passives: string[];
+  arbiters: string[];
+  tags: TagSet;
+  error: MongoError | null;
+  topologyVersion: TopologyVersion | null;
+  minWireVersion: number;
+  maxWireVersion: number;
+  roundTripTime: number;
+  /** The minimum measurement of the last 10 measurements of roundTripTime that have been collected */
+  minRoundTripTime: number;
+  lastUpdateTime: number;
+  lastWriteDate: number;
+  me: string | null;
+  primary: string | null;
+  setName: string | null;
+  setVersion: number | null;
+  electionId: ObjectId | null;
+  logicalSessionTimeoutMinutes: number | null;
+  /** The max message size in bytes for the server. */
+  maxMessageSizeBytes: number | null;
+  /** The max number of writes in a bulk write command. */
+  maxWriteBatchSize: number | null;
+  /** The max bson object size. */
+  maxBsonObjectSize: number | null;
+  /** Indicates server is a mongocryptd instance. */
+  iscryptd: boolean;
+
+  // NOTE: does this belong here? It seems we should gossip the cluster time at the CMAP level
+  $clusterTime?: ClusterTime;
+
+  /**
+   * Create a ServerDescription
+   * @internal
+   *
+   * @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 (address == null || address === '') {
+      throw new MongoRuntimeError('ServerDescription must be provided with a non-empty address');
+    }
+
+    this.address =
+      typeof address === 'string'
+        ? HostAddress.fromString(address).toString() // Use HostAddress to normalize
+        : address.toString();
+    this.type = parseServerType(hello, options);
+    this.hosts = hello?.hosts?.map((host: string) => host.toLowerCase()) ?? [];
+    this.passives = hello?.passives?.map((host: string) => host.toLowerCase()) ?? [];
+    this.arbiters = hello?.arbiters?.map((host: string) => host.toLowerCase()) ?? [];
+    this.tags = hello?.tags ?? {};
+    this.minWireVersion = hello?.minWireVersion ?? 0;
+    this.maxWireVersion = hello?.maxWireVersion ?? 0;
+    this.roundTripTime = options?.roundTripTime ?? -1;
+    this.minRoundTripTime = options?.minRoundTripTime ?? 0;
+    this.lastUpdateTime = processTimeMS();
+    this.lastWriteDate = hello?.lastWrite?.lastWriteDate ?? 0;
+    // NOTE: This actually builds the stack string instead of holding onto the getter and all its
+    // associated references. This is done to prevent a memory leak.
+    this.error = options.error ?? null;
+    this.error?.stack;
+    // 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.maxMessageSizeBytes = hello?.maxMessageSizeBytes ?? null;
+    this.maxWriteBatchSize = hello?.maxWriteBatchSize ?? null;
+    this.maxBsonObjectSize = hello?.maxBsonObjectSize ?? null;
+    this.primary = hello?.primary ?? null;
+    this.me = hello?.me?.toLowerCase() ?? null;
+    this.$clusterTime = hello?.$clusterTime ?? null;
+    this.iscryptd = Boolean(hello?.iscryptd);
+  }
+
+  get hostAddress(): HostAddress {
+    return HostAddress.fromString(this.address);
+  }
+
+  get allHosts(): string[] {
+    return this.hosts.concat(this.arbiters).concat(this.passives);
+  }
+
+  /** Is this server available for reads*/
+  get isReadable(): boolean {
+    return this.type === ServerType.RSSecondary || this.isWritable;
+  }
+
+  /** Is this server data bearing */
+  get isDataBearing(): boolean {
+    return DATA_BEARING_SERVER_TYPES.has(this.type);
+  }
+
+  /** Is this server available for writes */
+  get isWritable(): boolean {
+    return WRITABLE_SERVER_TYPES.has(this.type);
+  }
+
+  get host(): string {
+    const chopLength = `:${this.port}`.length;
+    return this.address.slice(0, -chopLength);
+  }
+
+  get port(): number {
+    const port = this.address.split(':').pop();
+    return port ? Number.parseInt(port, 10) : 27017;
+  }
+
+  /**
+   * Determines if another `ServerDescription` is equal to this one per the rules defined in the SDAM specification.
+   * @see https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.md
+   */
+  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;
+
+    const electionIdsEqual =
+      this.electionId != null && other?.electionId != null
+        ? compareObjectId(this.electionId, other.electionId) === 0
+        : this.electionId === other?.electionId;
+
+    return (
+      other != null &&
+      other.iscryptd === this.iscryptd &&
+      errorStrictEqual(this.error, other.error) &&
+      this.type === other.type &&
+      this.minWireVersion === other.minWireVersion &&
+      arrayStrictEqual(this.hosts, other.hosts) &&
+      tagsStrictEqual(this.tags, other.tags) &&
+      this.setName === other.setName &&
+      this.setVersion === other.setVersion &&
+      electionIdsEqual &&
+      this.primary === other.primary &&
+      this.logicalSessionTimeoutMinutes === other.logicalSessionTimeoutMinutes &&
+      topologyVersionsEqual
+    );
+  }
+}
+
+// Parses a `hello` message and determines the server type
+export function parseServerType(hello?: Document, options?: ServerDescriptionOptions): ServerType {
+  if (options?.loadBalanced) {
+    return ServerType.LoadBalancer;
+  }
+
+  if (!hello || !hello.ok) {
+    return ServerType.Unknown;
+  }
+
+  if (hello.isreplicaset) {
+    return ServerType.RSGhost;
+  }
+
+  if (hello.msg && hello.msg === 'isdbgrid') {
+    return ServerType.Mongos;
+  }
+
+  if (hello.setName) {
+    if (hello.hidden) {
+      return ServerType.RSOther;
+    } else if (hello.isWritablePrimary) {
+      return ServerType.RSPrimary;
+    } else if (hello.secondary) {
+      return ServerType.RSSecondary;
+    } else if (hello.arbiterOnly) {
+      return ServerType.RSArbiter;
+    } else {
+      return ServerType.RSOther;
+    }
+  }
+
+  return ServerType.Standalone;
+}
+
+function tagsStrictEqual(tags: TagSet, tags2: TagSet): boolean {
+  const tagsKeys = Object.keys(tags);
+  const tags2Keys = Object.keys(tags2);
+
+  return (
+    tagsKeys.length === tags2Keys.length &&
+    tagsKeys.every((key: string) => tags2[key] === tags[key])
+  );
+}
+
+/**
+ * Compares two topology versions.
+ *
+ * 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(
+  currentTv?: TopologyVersion | null,
+  newTv?: TopologyVersion | null
+): 0 | -1 | 1 {
+  if (currentTv == null || newTv == null) {
+    return -1;
+  }
+
+  if (!currentTv.processId.equals(newTv.processId)) {
+    return -1;
+  }
+
+  // TODO(NODE-2674): Preserve int64 sent from MongoDB
+  const currentCounter =
+    typeof currentTv.counter === 'bigint'
+      ? Long.fromBigInt(currentTv.counter)
+      : Long.isLong(currentTv.counter)
+        ? currentTv.counter
+        : Long.fromNumber(currentTv.counter);
+
+  const newCounter =
+    typeof newTv.counter === 'bigint'
+      ? Long.fromBigInt(newTv.counter)
+      : Long.isLong(newTv.counter)
+        ? newTv.counter
+        : Long.fromNumber(newTv.counter);
+
+  return currentCounter.compare(newCounter);
+}

package/src/sdam/server_selection.ts

@@ -0,0 +1,415 @@
+import { MongoInvalidArgumentError, MongoRuntimeError } from '../error';
+import { ReadPreference } from '../read_preference';
+import { ServerType, TopologyType } from './common';
+import type { ServerDescription, TagSet } from './server_description';
+import type { TopologyDescription } from './topology_description';
+
+// max staleness constants
+const IDLE_WRITE_PERIOD = 10000;
+const SMALLEST_MAX_STALENESS_SECONDS = 90;
+
+//  Minimum version to try writes on secondaries.
+export const MIN_SECONDARY_WRITE_WIRE_VERSION = 13;
+
+/** @internal */
+export type ServerSelector = (
+  topologyDescription: TopologyDescription,
+  servers: ServerDescription[],
+  deprioritized: DeprioritizedServers
+) => ServerDescription[];
+
+/** @internal */
+export class DeprioritizedServers {
+  private deprioritized: Set<string> = new Set();
+
+  constructor(descriptions?: Iterable<ServerDescription>) {
+    for (const description of descriptions ?? []) {
+      this.add(description);
+    }
+  }
+
+  add({ address }: ServerDescription) {
+    this.deprioritized.add(address);
+  }
+
+  has({ address }: ServerDescription): boolean {
+    return this.deprioritized.has(address);
+  }
+}
+
+function filterDeprioritized(
+  candidates: ServerDescription[],
+  deprioritized: DeprioritizedServers
+): ServerDescription[] {
+  const filtered = candidates.filter(candidate => !deprioritized.has(candidate));
+
+  return filtered.length ? filtered : candidates;
+}
+
+/**
+ * Returns a server selector that selects for writable servers
+ */
+export function writableServerSelector(): ServerSelector {
+  return function writableServer(
+    topologyDescription: TopologyDescription,
+    servers: ServerDescription[],
+    deprioritized: DeprioritizedServers
+  ): ServerDescription[] {
+    const eligibleServers = filterDeprioritized(
+      servers.filter(({ isWritable }) => isWritable),
+      deprioritized
+    );
+
+    return latencyWindowReducer(topologyDescription, eligibleServers);
+  };
+}
+
+/**
+ * The purpose of this selector is to select the same server, only
+ * if it is in a state that it can have commands sent to it.
+ */
+export function sameServerSelector(description?: ServerDescription): ServerSelector {
+  return function sameServerSelector(
+    _topologyDescription: TopologyDescription,
+    servers: ServerDescription[],
+    _deprioritized: DeprioritizedServers
+  ): ServerDescription[] {
+    if (!description) return [];
+    // Filter the servers to match the provided description only if
+    // the type is not unknown.
+    return servers.filter(sd => {
+      return sd.address === description.address && sd.type !== ServerType.Unknown;
+    });
+  };
+}
+
+/**
+ * Returns a server selector that uses a read preference to select a
+ * server potentially for a write on a secondary.
+ */
+export function secondaryWritableServerSelector(
+  wireVersion: number,
+  readPreference?: ReadPreference
+): ServerSelector {
+  // If server version < 5.0, read preference always primary.
+  // If server version >= 5.0...
+  // - If read preference is supplied, use that.
+  // - If no read preference is supplied, use primary.
+  if (
+    !readPreference ||
+    !wireVersion ||
+    (wireVersion && wireVersion < MIN_SECONDARY_WRITE_WIRE_VERSION)
+  ) {
+    return readPreferenceServerSelector(ReadPreference.primary);
+  }
+  return readPreferenceServerSelector(readPreference);
+}
+
+/**
+ * Reduces the passed in array of servers by the rules of the "Max Staleness" specification
+ * found here:
+ *
+ * @see https://github.com/mongodb/specifications/blob/master/source/max-staleness/max-staleness.md
+ *
+ * @param readPreference - The read preference providing max staleness guidance
+ * @param topologyDescription - The topology description
+ * @param servers - The list of server descriptions to be reduced
+ * @returns The list of servers that satisfy the requirements of max staleness
+ */
+function maxStalenessReducer(
+  readPreference: ReadPreference,
+  topologyDescription: TopologyDescription,
+  servers: ServerDescription[]
+): ServerDescription[] {
+  if (readPreference.maxStalenessSeconds == null || readPreference.maxStalenessSeconds < 0) {
+    return servers;
+  }
+
+  const maxStaleness = readPreference.maxStalenessSeconds;
+  const maxStalenessVariance =
+    (topologyDescription.heartbeatFrequencyMS + IDLE_WRITE_PERIOD) / 1000;
+  if (maxStaleness < maxStalenessVariance) {
+    throw new MongoInvalidArgumentError(
+      `Option "maxStalenessSeconds" must be at least ${maxStalenessVariance} seconds`
+    );
+  }
+
+  if (maxStaleness < SMALLEST_MAX_STALENESS_SECONDS) {
+    throw new MongoInvalidArgumentError(
+      `Option "maxStalenessSeconds" must be at least ${SMALLEST_MAX_STALENESS_SECONDS} seconds`
+    );
+  }
+
+  if (topologyDescription.type === TopologyType.ReplicaSetWithPrimary) {
+    const primary: ServerDescription = Array.from(topologyDescription.servers.values()).filter(
+      primaryFilter
+    )[0];
+
+    return servers.filter((server: ServerDescription) => {
+      const stalenessMS =
+        server.lastUpdateTime -
+        server.lastWriteDate -
+        (primary.lastUpdateTime - primary.lastWriteDate) +
+        topologyDescription.heartbeatFrequencyMS;
+
+      const staleness = stalenessMS / 1000;
+      const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0;
+      return staleness <= maxStalenessSeconds;
+    });
+  }
+
+  if (topologyDescription.type === TopologyType.ReplicaSetNoPrimary) {
+    if (servers.length === 0) {
+      return servers;
+    }
+
+    const sMax = servers.reduce((max: ServerDescription, s: ServerDescription) =>
+      s.lastWriteDate > max.lastWriteDate ? s : max
+    );
+
+    return servers.filter((server: ServerDescription) => {
+      const stalenessMS =
+        sMax.lastWriteDate - server.lastWriteDate + topologyDescription.heartbeatFrequencyMS;
+
+      const staleness = stalenessMS / 1000;
+      const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0;
+      return staleness <= maxStalenessSeconds;
+    });
+  }
+
+  return servers;
+}
+
+/**
+ * Determines whether a server's tags match a given set of tags.
+ *
+ * A tagset matches the server's tags if every k-v pair in the tagset
+ * is also in the server's tagset.
+ *
+ * Note that this does not requires that every k-v pair in the server's tagset is also
+ * in the client's tagset.  The server's tagset is required only to be a superset of the
+ * client's tags.
+ *
+ * @see https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.md#tag_sets
+ *
+ * @param tagSet - The requested tag set to match
+ * @param serverTags - The server's tags
+ */
+function tagSetMatch(tagSet: TagSet, serverTags: TagSet) {
+  return Object.entries(tagSet).every(
+    ([key, value]) => serverTags[key] != null && serverTags[key] === value
+  );
+}
+
+/**
+ * Reduces a set of server descriptions based on tags requested by the read preference
+ *
+ * @param readPreference - The read preference providing the requested tags
+ * @param servers - The list of server descriptions to reduce
+ * @returns The list of servers matching the requested tags
+ */
+function tagSetReducer(
+  { tags }: ReadPreference,
+  servers: ServerDescription[]
+): ServerDescription[] {
+  if (tags == null || tags.length === 0) {
+    // empty tag sets match all servers
+    return servers;
+  }
+
+  for (const tagSet of tags) {
+    const serversMatchingTagset = servers.filter((s: ServerDescription) =>
+      tagSetMatch(tagSet, s.tags)
+    );
+
+    if (serversMatchingTagset.length) {
+      return serversMatchingTagset;
+    }
+  }
+
+  return [];
+}
+
+/**
+ * Reduces a list of servers to ensure they fall within an acceptable latency window. This is
+ * further specified in the "Server Selection" specification, found here:
+ *
+ * @see https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.md
+ *
+ * @param topologyDescription - The topology description
+ * @param servers - The list of servers to reduce
+ * @returns The servers which fall within an acceptable latency window
+ */
+function latencyWindowReducer(
+  topologyDescription: TopologyDescription,
+  servers: ServerDescription[]
+): ServerDescription[] {
+  const low = servers.reduce(
+    (min: number, server: ServerDescription) => Math.min(server.roundTripTime, min),
+    Infinity
+  );
+
+  const high = low + topologyDescription.localThresholdMS;
+  return servers.filter(server => server.roundTripTime <= high && server.roundTripTime >= low);
+}
+
+// filters
+function primaryFilter(server: ServerDescription): boolean {
+  return server.type === ServerType.RSPrimary;
+}
+
+function secondaryFilter(server: ServerDescription): boolean {
+  return server.type === ServerType.RSSecondary;
+}
+
+function nearestFilter(server: ServerDescription): boolean {
+  return server.type === ServerType.RSSecondary || server.type === ServerType.RSPrimary;
+}
+
+function knownFilter(server: ServerDescription): boolean {
+  return server.type !== ServerType.Unknown;
+}
+
+function loadBalancerFilter(server: ServerDescription): boolean {
+  return server.type === ServerType.LoadBalancer;
+}
+
+function isDeprioritizedFactory(
+  deprioritized: DeprioritizedServers
+): (server: ServerDescription) => boolean {
+  return server =>
+    // if any deprioritized servers equal the server, here we are.
+    !deprioritized.has(server);
+}
+
+function secondarySelector(
+  readPreference: ReadPreference,
+  topologyDescription: TopologyDescription,
+  servers: ServerDescription[],
+  deprioritized: DeprioritizedServers
+) {
+  const mode = readPreference.mode;
+  switch (mode) {
+    case 'primary':
+      // Note: no need to filter for deprioritized servers.  A replica set has only one primary; that means that
+      // we are in one of two scenarios:
+      // 1. deprioritized servers is empty - return the primary.
+      // 2. deprioritized servers contains the primary - return the primary.
+      return servers.filter(primaryFilter);
+    case 'primaryPreferred': {
+      const primary = servers.filter(primaryFilter);
+
+      // If there is a primary and it is not deprioritized, use the primary.  Otherwise,
+      // check for secondaries.
+      const eligiblePrimary = primary.filter(isDeprioritizedFactory(deprioritized));
+      if (eligiblePrimary.length) {
+        return eligiblePrimary;
+      }
+
+      // If we make it here, we either have:
+      // 1. a deprioritized primary
+      // 2. no eligible primary
+      // secondaries take precedence of deprioritized primaries.
+      const secondaries = tagSetReducer(
+        readPreference,
+        maxStalenessReducer(readPreference, topologyDescription, servers.filter(secondaryFilter))
+      );
+
+      const eligibleSecondaries = secondaries.filter(isDeprioritizedFactory(deprioritized));
+      if (eligibleSecondaries.length) {
+        return latencyWindowReducer(topologyDescription, eligibleSecondaries);
+      }
+
+      // if we make it here, we have no primaries or secondaries that not deprioritized.
+      // prefer the primary (which may not exist, if the topology has no primary).
+      // otherwise, return the secondaries (which also may not exist, but there is nothing else to check here).
+      return primary.length ? primary : latencyWindowReducer(topologyDescription, secondaries);
+    }
+    case 'nearest': {
+      const eligible = filterDeprioritized(
+        tagSetReducer(
+          readPreference,
+          maxStalenessReducer(readPreference, topologyDescription, servers.filter(nearestFilter))
+        ),
+        deprioritized
+      );
+      return latencyWindowReducer(topologyDescription, eligible);
+    }
+    case 'secondary':
+    case 'secondaryPreferred': {
+      const secondaries = tagSetReducer(
+        readPreference,
+        maxStalenessReducer(readPreference, topologyDescription, servers.filter(secondaryFilter))
+      );
+      const eligibleSecondaries = secondaries.filter(isDeprioritizedFactory(deprioritized));
+
+      if (eligibleSecondaries.length) {
+        return latencyWindowReducer(topologyDescription, eligibleSecondaries);
+      }
+
+      // we have no eligible secondaries, try for a primary if we can.
+      if (mode === ReadPreference.SECONDARY_PREFERRED) {
+        const primary = servers.filter(primaryFilter);
+
+        // unlike readPreference=primary, here we do filter for deprioritized servers.
+        // if the primary is deprioritized, deprioritized secondaries take precedence.
+        const eligiblePrimary = primary.filter(isDeprioritizedFactory(deprioritized));
+        if (eligiblePrimary.length) return eligiblePrimary;
+
+        // we have no eligible primary nor secondaries that have not been deprioritized
+        return secondaries.length
+          ? latencyWindowReducer(topologyDescription, secondaries)
+          : primary;
+      }
+
+      // return all secondaries in the latency window.
+      return latencyWindowReducer(topologyDescription, secondaries);
+    }
+
+    default: {
+      const _exhaustiveCheck: never = mode;
+      throw new MongoRuntimeError(
+        `unexpected readPreference=${mode} (should never happen).  Please report a bug in the Node driver Jira project.`
+      );
+    }
+  }
+}
+
+/**
+ * Returns a function which selects servers based on a provided read preference
+ *
+ * @param readPreference - The read preference to select with
+ */
+export function readPreferenceServerSelector(readPreference: ReadPreference): ServerSelector {
+  if (!readPreference.isValid()) {
+    throw new MongoInvalidArgumentError('Invalid read preference specified');
+  }
+
+  return function readPreferenceServers(
+    topologyDescription: TopologyDescription,
+    servers: ServerDescription[],
+    deprioritized: DeprioritizedServers
+  ): ServerDescription[] {
+    switch (topologyDescription.type) {
+      case 'Single':
+        return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
+      case 'ReplicaSetNoPrimary':
+      case 'ReplicaSetWithPrimary':
+        return secondarySelector(readPreference, topologyDescription, servers, deprioritized);
+      case 'Sharded': {
+        const selectable = filterDeprioritized(servers, deprioritized);
+        return latencyWindowReducer(topologyDescription, selectable.filter(knownFilter));
+      }
+      case 'Unknown':
+        return [];
+      case 'LoadBalanced':
+        return servers.filter(loadBalancerFilter);
+      default: {
+        const _exhaustiveCheck: never = topologyDescription.type;
+        throw new MongoRuntimeError(
+          `unexpected topology type: ${topologyDescription.type} (this should never happen).  Please file a bug in the Node driver Jira project.`
+        );
+      }
+    }
+  };
+}