@nullix/zod-mongoose-studio 1.0.13 → 2.0.0

package/.output/server/node_modules/mongodb/lib/read_preference.js

@@ -18,6 +18,16 @@ exports.ReadPreferenceMode = Object.freeze({
  * @see https://www.mongodb.com/docs/manual/core/read-preference/
  */
 class ReadPreference {
+    static { this.PRIMARY = exports.ReadPreferenceMode.primary; }
+    static { this.PRIMARY_PREFERRED = exports.ReadPreferenceMode.primaryPreferred; }
+    static { this.SECONDARY = exports.ReadPreferenceMode.secondary; }
+    static { this.SECONDARY_PREFERRED = exports.ReadPreferenceMode.secondaryPreferred; }
+    static { this.NEAREST = exports.ReadPreferenceMode.nearest; }
+    static { this.primary = new ReadPreference(exports.ReadPreferenceMode.primary); }
+    static { this.primaryPreferred = new ReadPreference(exports.ReadPreferenceMode.primaryPreferred); }
+    static { this.secondary = new ReadPreference(exports.ReadPreferenceMode.secondary); }
+    static { this.secondaryPreferred = new ReadPreference(exports.ReadPreferenceMode.secondaryPreferred); }
+    static { this.nearest = new ReadPreference(exports.ReadPreferenceMode.nearest); }
     /**
      * @param mode - A string describing the read preference mode (primary|primaryPreferred|secondary|secondaryPreferred|nearest)
      * @param tags - A tag set used to target reads to members with the specified tag(s). tagSet is not available if using read preference mode primary.
@@ -38,16 +48,12 @@ class ReadPreference {
         this.tags = tags;
         this.hedge = options?.hedge;
         this.maxStalenessSeconds = undefined;
-        this.minWireVersion = undefined;
         options = options ?? {};
         if (options.maxStalenessSeconds != null) {
             if (options.maxStalenessSeconds <= 0) {
                 throw new error_1.MongoInvalidArgumentError('maxStalenessSeconds must be a positive integer');
             }
             this.maxStalenessSeconds = options.maxStalenessSeconds;
-            // NOTE: The minimum required wire version is 5 for this read preference. If the existing
-            //       topology has a lower value then a MongoError will be thrown during server selection.
-            this.minWireVersion = 5;
         }
         if (this.mode === ReadPreference.PRIMARY) {
             if (this.tags && Array.isArray(this.tags) && this.tags.length > 0) {
@@ -182,14 +188,4 @@ class ReadPreference {
     }
 }
 exports.ReadPreference = ReadPreference;
-ReadPreference.PRIMARY = exports.ReadPreferenceMode.primary;
-ReadPreference.PRIMARY_PREFERRED = exports.ReadPreferenceMode.primaryPreferred;
-ReadPreference.SECONDARY = exports.ReadPreferenceMode.secondary;
-ReadPreference.SECONDARY_PREFERRED = exports.ReadPreferenceMode.secondaryPreferred;
-ReadPreference.NEAREST = exports.ReadPreferenceMode.nearest;
-ReadPreference.primary = new ReadPreference(exports.ReadPreferenceMode.primary);
-ReadPreference.primaryPreferred = new ReadPreference(exports.ReadPreferenceMode.primaryPreferred);
-ReadPreference.secondary = new ReadPreference(exports.ReadPreferenceMode.secondary);
-ReadPreference.secondaryPreferred = new ReadPreference(exports.ReadPreferenceMode.secondaryPreferred);
-ReadPreference.nearest = new ReadPreference(exports.ReadPreferenceMode.nearest);
 //# sourceMappingURL=read_preference.js.map

package/.output/server/node_modules/mongodb/lib/runtime_adapters.js

@@ -0,0 +1,32 @@
+"use strict";
+/* eslint-disable no-restricted-imports*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_DRIVER_REQUIRE_PROPERTY_NAME = void 0;
+exports.resolveRuntimeAdapters = resolveRuntimeAdapters;
+/**
+ * @internal
+ *
+ * This propery can be set on the global object to allow the driver to require otherwise blocked modules.
+ * This is used by our test suite to allow tests to access the `os` module without allowing user code to do so.
+ */
+exports.ALLOWED_DRIVER_REQUIRE_PROPERTY_NAME = 'allowedDriverRequire';
+/**
+ * @internal
+ *
+ * Given a MongoClientOptions, this function resolves the set of runtime options, providing Nodejs implementations if
+ * not provided by in `options`, and returns a `Runtime`.
+ */
+function resolveRuntimeAdapters(options) {
+    globalThis[exports.ALLOWED_DRIVER_REQUIRE_PROPERTY_NAME] = true;
+    try {
+        const runtime = {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            os: options.runtimeAdapters?.os ?? require('os')
+        };
+        return runtime;
+    }
+    finally {
+        globalThis[exports.ALLOWED_DRIVER_REQUIRE_PROPERTY_NAME] = false;
+    }
+}
+//# sourceMappingURL=runtime_adapters.js.map

package/.output/server/node_modules/mongodb/lib/sdam/monitor.js

@@ -207,7 +207,7 @@ function checkServer(monitor, callback) {
             monitor.emitAndLogHeartbeat(server_1.Server.SERVER_HEARTBEAT_STARTED, monitor.server.topology.s.id, undefined, new events_1.ServerHeartbeatStartedEvent(monitor.address, true));
             // We have not actually sent an outgoing handshake, but when we get the next response we
             // want the duration to reflect the time since we last heard from the server
-            start = (0, utils_1.now)();
+            start = (0, utils_1.processTimeMS)();
         }
         else {
             monitor.rttPinger?.close();
@@ -236,7 +236,7 @@ function checkServer(monitor, callback) {
             monitor.rttPinger = new RTTPinger(monitor);
         }
         // Record new start time before sending handshake
-        start = (0, utils_1.now)();
+        start = (0, utils_1.processTimeMS)();
         if (isAwaitable) {
             awaited = true;
             return connection.exhaustCommand((0, utils_1.ns)('admin.$cmd'), cmd, options, (error, hello) => {
@@ -256,7 +256,7 @@ function checkServer(monitor, callback) {
         const socket = await (0, connect_1.makeSocket)(monitor.connectOptions);
         const connection = (0, connect_1.makeConnection)(monitor.connectOptions, socket);
         // The start time is after socket creation but before the handshake
-        start = (0, utils_1.now)();
+        start = (0, utils_1.processTimeMS)();
         try {
             await (0, connect_1.performInitialHandshake)(connection, monitor.connectOptions);
             return connection;
@@ -284,7 +284,7 @@ function checkServer(monitor, callback) {
 function monitorServer(monitor) {
     return (callback) => {
         if (monitor.s.state === STATE_MONITORING) {
-            process.nextTick(callback);
+            queueMicrotask(callback);
             return;
         }
         stateTransition(monitor, STATE_MONITORING);
@@ -356,7 +356,7 @@ class RTTPinger {
         this.monitorId = (0, timers_1.setTimeout)(() => this.measureRoundTripTime(), this.monitor.options.heartbeatFrequencyMS);
     }
     measureRoundTripTime() {
-        const start = (0, utils_1.now)();
+        const start = (0, utils_1.processTimeMS)();
         if (this.closed) {
             return;
         }
@@ -396,7 +396,7 @@ class MonitorInterval {
             this.isExpeditedCallToFnScheduled = false;
             this.isExecutionInProgress = true;
             this.fn(() => {
-                this.lastExecutionEnded = (0, utils_1.now)();
+                this.lastExecutionEnded = (0, utils_1.processTimeMS)();
                 this.isExecutionInProgress = false;
                 this._reschedule(this.heartbeatFrequencyMS);
             });
@@ -413,7 +413,7 @@ class MonitorInterval {
         }
     }
     wake() {
-        const currentTime = (0, utils_1.now)();
+        const currentTime = (0, utils_1.processTimeMS)();
         const timeSinceLastCall = currentTime - this.lastExecutionEnded;
         // TODO(NODE-4674): Add error handling and logging to the monitor
         if (timeSinceLastCall < 0) {
@@ -448,7 +448,7 @@ class MonitorInterval {
         return JSON.stringify(this);
     }
     toJSON() {
-        const currentTime = (0, utils_1.now)();
+        const currentTime = (0, utils_1.processTimeMS)();
         const timeSinceLastCall = currentTime - this.lastExecutionEnded;
         return {
             timerId: this.timerId != null ? 'set' : 'cleared',

package/.output/server/node_modules/mongodb/lib/sdam/server.js

@@ -23,6 +23,20 @@ const stateTransition = (0, utils_1.makeStateMachine)({
 });
 /** @internal */
 class Server extends mongo_types_1.TypedEventEmitter {
+    /** @event */
+    static { this.SERVER_HEARTBEAT_STARTED = constants_1.SERVER_HEARTBEAT_STARTED; }
+    /** @event */
+    static { this.SERVER_HEARTBEAT_SUCCEEDED = constants_1.SERVER_HEARTBEAT_SUCCEEDED; }
+    /** @event */
+    static { this.SERVER_HEARTBEAT_FAILED = constants_1.SERVER_HEARTBEAT_FAILED; }
+    /** @event */
+    static { this.CONNECT = constants_1.CONNECT; }
+    /** @event */
+    static { this.DESCRIPTION_RECEIVED = constants_1.DESCRIPTION_RECEIVED; }
+    /** @event */
+    static { this.CLOSED = constants_1.CLOSED; }
+    /** @event */
+    static { this.ENDED = constants_1.ENDED; }
     /**
      * Create a server
      */
@@ -201,7 +215,7 @@ class Server extends mongo_types_1.TypedEventEmitter {
         }
         catch (operationError) {
             if (operationError instanceof error_1.MongoError &&
-                operationError.code === error_1.MONGODB_ERROR_CODES.Reauthenticate) {
+                operationError.code?.valueOf() === error_1.MONGODB_ERROR_CODES.Reauthenticate) {
                 reauthPromise = this.pool.reauthenticate(conn);
                 reauthPromise.then(undefined, error => {
                     reauthPromise = null;
@@ -234,39 +248,47 @@ class Server extends mongo_types_1.TypedEventEmitter {
         if (!(error instanceof error_1.MongoError)) {
             return;
         }
-        const isStaleError = error.connectionGeneration && error.connectionGeneration < this.pool.generation;
-        if (isStaleError) {
+        if (isStaleError(this, error)) {
             return;
         }
         const isNetworkNonTimeoutError = error instanceof error_1.MongoNetworkError && !(error instanceof error_1.MongoNetworkTimeoutError);
         const isNetworkTimeoutBeforeHandshakeError = error instanceof error_1.MongoNetworkError && error.beforeHandshake;
-        const isAuthHandshakeError = error.hasErrorLabel(error_1.MongoErrorLabel.HandshakeError);
-        if (isNetworkNonTimeoutError || isNetworkTimeoutBeforeHandshakeError || isAuthHandshakeError) {
-            // In load balanced mode we never mark the server as unknown and always
-            // clear for the specific service id.
+        const isAuthOrEstablishmentHandshakeError = error.hasErrorLabel(error_1.MongoErrorLabel.HandshakeError);
+        const isSystemOverloadError = error.hasErrorLabel(error_1.MongoErrorLabel.SystemOverloadedError);
+        // Perhaps questionable and divergent from the spec, but considering MongoParseErrors like state change errors was legacy behavior.
+        if ((0, error_1.isStateChangeError)(error) || error instanceof error_1.MongoParseError) {
+            const shouldClearPool = (0, error_1.isNodeShuttingDownError)(error);
+            // from the SDAM spec: The driver MUST synchronize clearing the pool with updating the topology.
+            // In load balanced mode: there is no monitoring, so there is no topology to update.  We simply clear the pool.
+            // For other topologies: the `ResetPool` label instructs the topology to clear the server's pool in `updateServer()`.
             if (!this.loadBalanced) {
-                error.addErrorLabel(error_1.MongoErrorLabel.ResetPool);
+                if (shouldClearPool) {
+                    error.addErrorLabel(error_1.MongoErrorLabel.ResetPool);
+                }
                 markServerUnknown(this, error);
+                queueMicrotask(() => this.requestCheck());
+                return;
             }
-            else if (connection) {
+            if (connection && shouldClearPool) {
                 this.pool.clear({ serviceId: connection.serviceId });
             }
         }
-        else {
-            if ((0, error_1.isSDAMUnrecoverableError)(error)) {
-                if (shouldHandleStateChangeError(this, error)) {
-                    const shouldClearPool = (0, error_1.isNodeShuttingDownError)(error);
-                    if (this.loadBalanced && connection && shouldClearPool) {
-                        this.pool.clear({ serviceId: connection.serviceId });
-                    }
-                    if (!this.loadBalanced) {
-                        if (shouldClearPool) {
-                            error.addErrorLabel(error_1.MongoErrorLabel.ResetPool);
-                        }
-                        markServerUnknown(this, error);
-                        process.nextTick(() => this.requestCheck());
-                    }
-                }
+        else if (isNetworkNonTimeoutError ||
+            isNetworkTimeoutBeforeHandshakeError ||
+            isAuthOrEstablishmentHandshakeError) {
+            // Do NOT clear the pool if we encounter a system overloaded error.
+            if (isSystemOverloadError) {
+                return;
+            }
+            // from the SDAM spec: The driver MUST synchronize clearing the pool with updating the topology.
+            // In load balanced mode: there is no monitoring, so there is no topology to update.  We simply clear the pool.
+            // For other topologies: the `ResetPool` label instructs the topology to clear the server's pool in `updateServer()`.
+            if (!this.loadBalanced) {
+                error.addErrorLabel(error_1.MongoErrorLabel.ResetPool);
+                markServerUnknown(this, error);
+            }
+            else if (connection) {
+                this.pool.clear({ serviceId: connection.serviceId });
             }
         }
     }
@@ -333,20 +355,6 @@ class Server extends mongo_types_1.TypedEventEmitter {
     }
 }
 exports.Server = Server;
-/** @event */
-Server.SERVER_HEARTBEAT_STARTED = constants_1.SERVER_HEARTBEAT_STARTED;
-/** @event */
-Server.SERVER_HEARTBEAT_SUCCEEDED = constants_1.SERVER_HEARTBEAT_SUCCEEDED;
-/** @event */
-Server.SERVER_HEARTBEAT_FAILED = constants_1.SERVER_HEARTBEAT_FAILED;
-/** @event */
-Server.CONNECT = constants_1.CONNECT;
-/** @event */
-Server.DESCRIPTION_RECEIVED = constants_1.DESCRIPTION_RECEIVED;
-/** @event */
-Server.CLOSED = constants_1.CLOSED;
-/** @event */
-Server.ENDED = constants_1.ENDED;
 function markServerUnknown(server, error) {
     // Load balancer servers can never be marked unknown.
     if (server.loadBalanced) {
@@ -376,11 +384,6 @@ function connectionIsStale(pool, connection) {
     }
     return connection.generation !== pool.generation;
 }
-function shouldHandleStateChangeError(server, err) {
-    const etv = err.topologyVersion;
-    const stv = server.description.topologyVersion;
-    return (0, server_description_1.compareTopologyVersion)(stv, etv) < 0;
-}
 function inActiveTransaction(session, cmd) {
     return session && session.inTransaction() && !(0, transactions_1.isTransactionCommand)(cmd);
 }
@@ -389,4 +392,13 @@ function inActiveTransaction(session, cmd) {
 function isRetryableWritesEnabled(topology) {
     return topology.s.options.retryWrites !== false;
 }
+function isStaleError(server, error) {
+    const currentGeneration = server.pool.generation;
+    const generation = error.connectionGeneration;
+    if (generation && generation < currentGeneration) {
+        return true;
+    }
+    const currentTopologyVersion = server.description.topologyVersion;
+    return (0, server_description_1.compareTopologyVersion)(currentTopologyVersion, error.topologyVersion) >= 0;
+}
 //# sourceMappingURL=server.js.map

package/.output/server/node_modules/mongodb/lib/sdam/server_description.js

@@ -51,7 +51,7 @@ class ServerDescription {
         this.maxWireVersion = hello?.maxWireVersion ?? 0;
         this.roundTripTime = options?.roundTripTime ?? -1;
         this.minRoundTripTime = options?.minRoundTripTime ?? 0;
-        this.lastUpdateTime = (0, utils_1.now)();
+        this.lastUpdateTime = (0, utils_1.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.

package/.output/server/node_modules/mongodb/lib/sdam/server_selection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MIN_SECONDARY_WRITE_WIRE_VERSION = void 0;
+exports.DeprioritizedServers = exports.MIN_SECONDARY_WRITE_WIRE_VERSION = void 0;
 exports.writableServerSelector = writableServerSelector;
 exports.sameServerSelector = sameServerSelector;
 exports.secondaryWritableServerSelector = secondaryWritableServerSelector;
@@ -13,12 +13,33 @@ const IDLE_WRITE_PERIOD = 10000;
 const SMALLEST_MAX_STALENESS_SECONDS = 90;
 //  Minimum version to try writes on secondaries.
 exports.MIN_SECONDARY_WRITE_WIRE_VERSION = 13;
+/** @internal */
+class DeprioritizedServers {
+    constructor(descriptions) {
+        this.deprioritized = new Set();
+        for (const description of descriptions ?? []) {
+            this.add(description);
+        }
+    }
+    add({ address }) {
+        this.deprioritized.add(address);
+    }
+    has({ address }) {
+        return this.deprioritized.has(address);
+    }
+}
+exports.DeprioritizedServers = DeprioritizedServers;
+function filterDeprioritized(candidates, deprioritized) {
+    const filtered = candidates.filter(candidate => !deprioritized.has(candidate));
+    return filtered.length ? filtered : candidates;
+}
 /**
  * Returns a server selector that selects for writable servers
  */
 function writableServerSelector() {
-    return function writableServer(topologyDescription, servers) {
-        return latencyWindowReducer(topologyDescription, servers.filter((s) => s.isWritable));
+    return function writableServer(topologyDescription, servers, deprioritized) {
+        const eligibleServers = filterDeprioritized(servers.filter(({ isWritable }) => isWritable), deprioritized);
+        return latencyWindowReducer(topologyDescription, eligibleServers);
     };
 }
 /**
@@ -26,7 +47,7 @@ function writableServerSelector() {
  * if it is in a state that it can have commands sent to it.
  */
 function sameServerSelector(description) {
-    return function sameServerSelector(topologyDescription, servers) {
+    return function sameServerSelector(_topologyDescription, servers, _deprioritized) {
         if (!description)
             return [];
         // Filter the servers to match the provided description only if
@@ -77,52 +98,47 @@ function maxStalenessReducer(readPreference, topologyDescription, servers) {
     }
     if (topologyDescription.type === common_1.TopologyType.ReplicaSetWithPrimary) {
         const primary = Array.from(topologyDescription.servers.values()).filter(primaryFilter)[0];
-        return servers.reduce((result, server) => {
+        return servers.filter((server) => {
             const stalenessMS = server.lastUpdateTime -
                 server.lastWriteDate -
                 (primary.lastUpdateTime - primary.lastWriteDate) +
                 topologyDescription.heartbeatFrequencyMS;
             const staleness = stalenessMS / 1000;
             const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0;
-            if (staleness <= maxStalenessSeconds) {
-                result.push(server);
-            }
-            return result;
-        }, []);
+            return staleness <= maxStalenessSeconds;
+        });
     }
     if (topologyDescription.type === common_1.TopologyType.ReplicaSetNoPrimary) {
         if (servers.length === 0) {
             return servers;
         }
         const sMax = servers.reduce((max, s) => s.lastWriteDate > max.lastWriteDate ? s : max);
-        return servers.reduce((result, server) => {
+        return servers.filter((server) => {
             const stalenessMS = sMax.lastWriteDate - server.lastWriteDate + topologyDescription.heartbeatFrequencyMS;
             const staleness = stalenessMS / 1000;
             const maxStalenessSeconds = readPreference.maxStalenessSeconds ?? 0;
-            if (staleness <= maxStalenessSeconds) {
-                result.push(server);
-            }
-            return result;
-        }, []);
+            return staleness <= maxStalenessSeconds;
+        });
     }
     return servers;
 }
 /**
- * Determines whether a server's tags match a given set of tags
+ * 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, serverTags) {
-    const keys = Object.keys(tagSet);
-    const serverTagKeys = Object.keys(serverTags);
-    for (let i = 0; i < keys.length; ++i) {
-        const key = keys[i];
-        if (serverTagKeys.indexOf(key) === -1 || serverTags[key] !== tagSet[key]) {
-            return false;
-        }
-    }
-    return true;
+    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
@@ -131,18 +147,13 @@ function tagSetMatch(tagSet, serverTags) {
  * @param servers - The list of server descriptions to reduce
  * @returns The list of servers matching the requested tags
  */
-function tagSetReducer(readPreference, servers) {
-    if (readPreference.tags == null ||
-        (Array.isArray(readPreference.tags) && readPreference.tags.length === 0)) {
+function tagSetReducer({ tags }, servers) {
+    if (tags == null || tags.length === 0) {
+        // empty tag sets match all servers
         return servers;
     }
-    for (let i = 0; i < readPreference.tags.length; ++i) {
-        const tagSet = readPreference.tags[i];
-        const serversMatchingTagset = servers.reduce((matched, server) => {
-            if (tagSetMatch(tagSet, server.tags))
-                matched.push(server);
-            return matched;
-        }, []);
+    for (const tagSet of tags) {
+        const serversMatchingTagset = servers.filter((s) => tagSetMatch(tagSet, s.tags));
         if (serversMatchingTagset.length) {
             return serversMatchingTagset;
         }
@@ -162,11 +173,7 @@ function tagSetReducer(readPreference, servers) {
 function latencyWindowReducer(topologyDescription, servers) {
     const low = servers.reduce((min, server) => Math.min(server.roundTripTime, min), Infinity);
     const high = low + topologyDescription.localThresholdMS;
-    return servers.reduce((result, server) => {
-        if (server.roundTripTime <= high && server.roundTripTime >= low)
-            result.push(server);
-        return result;
-    }, []);
+    return servers.filter(server => server.roundTripTime <= high && server.roundTripTime >= low);
 }
 // filters
 function primaryFilter(server) {
@@ -184,6 +191,75 @@ function knownFilter(server) {
 function loadBalancerFilter(server) {
     return server.type === common_1.ServerType.LoadBalancer;
 }
+function isDeprioritizedFactory(deprioritized) {
+    return server => 
+    // if any deprioritized servers equal the server, here we are.
+    !deprioritized.has(server);
+}
+function secondarySelector(readPreference, topologyDescription, servers, deprioritized) {
+    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 === read_preference_1.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 = mode;
+            throw new error_1.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
  *
@@ -193,39 +269,26 @@ function readPreferenceServerSelector(readPreference) {
     if (!readPreference.isValid()) {
         throw new error_1.MongoInvalidArgumentError('Invalid read preference specified');
     }
-    return function readPreferenceServers(topologyDescription, servers, deprioritized = []) {
-        if (topologyDescription.type === common_1.TopologyType.LoadBalanced) {
-            return servers.filter(loadBalancerFilter);
-        }
-        if (topologyDescription.type === common_1.TopologyType.Unknown) {
-            return [];
-        }
-        if (topologyDescription.type === common_1.TopologyType.Single) {
-            return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
-        }
-        if (topologyDescription.type === common_1.TopologyType.Sharded) {
-            const filtered = servers.filter(server => {
-                return !deprioritized.includes(server);
-            });
-            const selectable = filtered.length > 0 ? filtered : deprioritized;
-            return latencyWindowReducer(topologyDescription, selectable.filter(knownFilter));
-        }
-        const mode = readPreference.mode;
-        if (mode === read_preference_1.ReadPreference.PRIMARY) {
-            return servers.filter(primaryFilter);
-        }
-        if (mode === read_preference_1.ReadPreference.PRIMARY_PREFERRED) {
-            const result = servers.filter(primaryFilter);
-            if (result.length) {
-                return result;
+    return function readPreferenceServers(topologyDescription, servers, deprioritized) {
+        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 = topologyDescription.type;
+                throw new error_1.MongoRuntimeError(`unexpected topology type: ${topologyDescription.type} (this should never happen).  Please file a bug in the Node driver Jira project.`);
             }
         }
-        const filter = mode === read_preference_1.ReadPreference.NEAREST ? nearestFilter : secondaryFilter;
-        const selectedServers = latencyWindowReducer(topologyDescription, tagSetReducer(readPreference, maxStalenessReducer(readPreference, topologyDescription, servers.filter(filter))));
-        if (mode === read_preference_1.ReadPreference.SECONDARY_PREFERRED && selectedServers.length === 0) {
-            return servers.filter(primaryFilter);
-        }
-        return selectedServers;
     };
 }
 //# sourceMappingURL=server_selection.js.map

package/.output/server/node_modules/mongodb/lib/sdam/srv_polling.js

@@ -21,6 +21,8 @@ class SrvPollingEvent {
 exports.SrvPollingEvent = SrvPollingEvent;
 /** @internal */
 class SrvPoller extends mongo_types_1.TypedEventEmitter {
+    /** @event */
+    static { this.SRV_RECORD_DISCOVERY = 'srvRecordDiscovery'; }
     constructor(options) {
         super();
         this.on('error', utils_1.noop);
@@ -76,7 +78,7 @@ class SrvPoller extends mongo_types_1.TypedEventEmitter {
         const generation = this.generation;
         let srvRecords;
         try {
-            srvRecords = await dns.promises.resolveSrv(this.srvAddress);
+            srvRecords = await dns.promises.resolve(this.srvAddress, 'SRV');
         }
         catch {
             this.failure();
@@ -103,6 +105,4 @@ class SrvPoller extends mongo_types_1.TypedEventEmitter {
     }
 }
 exports.SrvPoller = SrvPoller;
-/** @event */
-SrvPoller.SRV_RECORD_DISCOVERY = 'srvRecordDiscovery';
 //# sourceMappingURL=srv_polling.js.map